okio/src/jvmTest/kotlin/okio/TestUtil.kt - platform/external/okio - Git at Google

 /*
  * Copyright (C) 2014 Square, Inc.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 package okio

 import okio.ByteString.Companion.encodeUtf8
 import org.junit.Assume
 import java.io.IOException
 import java.io.ObjectInputStream
 import java.io.ObjectOutputStream
 import java.io.Serializable
 import java.util.Random
 import kotlin.test.assertEquals
 import kotlin.test.assertFalse
 import kotlin.test.assertTrue

 object TestUtil {
   // Necessary to make an internal member visible to Java.
   @JvmField val SEGMENT_POOL_MAX_SIZE = SegmentPool.MAX_SIZE
   const val SEGMENT_SIZE = Segment.SIZE
   const val REPLACEMENT_CODE_POINT: Int = okio.REPLACEMENT_CODE_POINT

   @JvmStatic fun segmentPoolByteCount() = SegmentPool.byteCount

   @JvmStatic
   fun segmentSizes(buffer: Buffer): List<Int> = okio.segmentSizes(buffer)

   @JvmStatic
   fun assertNoEmptySegments(buffer: Buffer) {
     assertTrue(segmentSizes(buffer).all { it != 0 }, "Expected all segments to be non-empty")
   }

   @JvmStatic
   fun assertByteArraysEquals(a: ByteArray, b: ByteArray) {
     assertEquals(a.contentToString(), b.contentToString())
   }

   @JvmStatic
   fun assertByteArrayEquals(expectedUtf8: String, b: ByteArray) {
     assertEquals(expectedUtf8, b.toString(Charsets.UTF_8))
   }

   @JvmStatic
   fun randomBytes(length: Int): ByteString {
     val random = Random(0)
     val randomBytes = ByteArray(length)
     random.nextBytes(randomBytes)
     return ByteString.of(*randomBytes)
   }

   @JvmStatic
   fun randomSource(size: Long): Source {
     return object : Source {
       internal var random = Random(0)
       internal var bytesLeft = size
       internal var closed: Boolean = false

       @Throws(IOException::class)
       override fun read(sink: Buffer, byteCount: Long): Long {
         var byteCount = byteCount
         if (closed) throw IllegalStateException("closed")
         if (bytesLeft == 0L) return -1L
         if (byteCount > bytesLeft) byteCount = bytesLeft

         // If we can read a full segment we can save a copy.
         if (byteCount >= Segment.SIZE) {
           val segment = sink.writableSegment(Segment.SIZE)
           random.nextBytes(segment.data)
           segment.limit += Segment.SIZE
           sink.size += Segment.SIZE.toLong()
           bytesLeft -= Segment.SIZE.toLong()
           return Segment.SIZE.toLong()
         } else {
           val data = ByteArray(byteCount.toInt())
           random.nextBytes(data)
           sink.write(data)
           bytesLeft -= byteCount
           return byteCount
         }
       }

       override fun timeout() = Timeout.NONE

       @Throws(IOException::class)
       override fun close() {
         closed = true
       }
     }
   }

   @JvmStatic
   fun assertEquivalent(b1: ByteString, b2: ByteString) {
     // Equals.
     assertTrue(b1 == b2)
     assertTrue(b1 == b1)
     assertTrue(b2 == b1)

     // Hash code.
     assertEquals(b1.hashCode().toLong(), b2.hashCode().toLong())
     assertEquals(b1.hashCode().toLong(), b1.hashCode().toLong())
     assertEquals(b1.toString(), b2.toString())

     // Content.
     assertEquals(b1.size.toLong(), b2.size.toLong())
     val b2Bytes = b2.toByteArray()
     for (i in b2Bytes.indices) {
       val b = b2Bytes[i]
       assertEquals(b.toLong(), b1[i].toLong())
     }
     assertByteArraysEquals(b1.toByteArray(), b2Bytes)

     // Doesn't equal a different byte string.
     assertFalse(b1 == null)
     assertFalse(b1 == Any())
     if (b2Bytes.size > 0) {
       val b3Bytes = b2Bytes.clone()
       b3Bytes[b3Bytes.size - 1]++
       val b3 = ByteString(b3Bytes)
       assertFalse(b1 == b3)
       assertFalse(b1.hashCode() == b3.hashCode())
     } else {
       val b3 = "a".encodeUtf8()
       assertFalse(b1 == b3)
       assertFalse(b1.hashCode() == b3.hashCode())
     }
   }

   @JvmStatic
   fun assertEquivalent(b1: Buffer, b2: Buffer) {
     // Equals.
     assertTrue(b1 == b2)
     assertTrue(b1 == b1)
     assertTrue(b2 == b1)

     // Hash code.
     assertEquals(b1.hashCode().toLong(), b2.hashCode().toLong())
     assertEquals(b1.hashCode().toLong(), b1.hashCode().toLong())
     assertEquals(b1.toString(), b2.toString())

     // Content.
     assertEquals(b1.size, b2.size)
     val buffer = Buffer()
     b2.copyTo(buffer, 0, b2.size)
     val b2Bytes = b2.readByteArray()
     for (i in b2Bytes.indices) {
       val b = b2Bytes[i]
       assertEquals(b.toLong(), b1[i.toLong()].toLong())
     }

     // Doesn't equal a different buffer.
     assertFalse(b1 == Any())
     if (b2Bytes.size > 0) {
       val b3Bytes = b2Bytes.clone()
       b3Bytes[b3Bytes.size - 1]++
       val b3 = Buffer().write(b3Bytes)
       assertFalse(b1 == b3)
       assertFalse(b1.hashCode() == b3.hashCode())
     } else {
       val b3 = Buffer().writeUtf8("a")
       assertFalse(b1 == b3)
       assertFalse(b1.hashCode() == b3.hashCode())
     }
   }

   /** Serializes original to bytes, then deserializes those bytes and returns the result.  */
   @Suppress("UNCHECKED_CAST")
   @Throws(Exception::class)
   @JvmStatic
   // Assume serialization doesn't change types.
   fun <T : Serializable> reserialize(original: T): T {
     val buffer = Buffer()
     val out = ObjectOutputStream(buffer.outputStream())
     out.writeObject(original)
     val input = ObjectInputStream(buffer.inputStream())
     return input.readObject() as T
   }

   /**
    * Returns a new buffer containing the data in `data` and a segment
    * layout determined by `dice`.
    */
   @Throws(IOException::class)
   @JvmStatic
   fun bufferWithRandomSegmentLayout(dice: Random, data: ByteArray): Buffer {
     val result = Buffer()

     // Writing to result directly will yield packed segments. Instead, write to
     // other buffers, then write those buffers to result.
     var pos = 0
     var byteCount: Int
     while (pos < data.size) {
       byteCount = Segment.SIZE / 2 + dice.nextInt(Segment.SIZE / 2)
       if (byteCount > data.size - pos) byteCount = data.size - pos
       val offset = dice.nextInt(Segment.SIZE - byteCount)

       val segment = Buffer()
       segment.write(ByteArray(offset))
       segment.write(data, pos, byteCount)
       segment.skip(offset.toLong())

       result.write(segment, byteCount.toLong())
       pos += byteCount
     }

     return result
   }

   /**
    * Returns a new buffer containing the contents of `segments`, attempting to isolate each
    * string to its own segment in the returned buffer. This clones buffers so that segments are
    * shared, preventing compaction from occurring.
    */
   @Throws(Exception::class)
   @JvmStatic
   fun bufferWithSegments(vararg segments: String): Buffer {
     val result = Buffer()
     for (s in segments) {
       val offsetInSegment = if (s.length < Segment.SIZE) (Segment.SIZE - s.length) / 2 else 0
       val buffer = Buffer()
       buffer.writeUtf8("_".repeat(offsetInSegment))
       buffer.writeUtf8(s)
       buffer.skip(offsetInSegment.toLong())
       result.write(buffer.clone(), buffer.size)
     }
     return result
   }

   @JvmStatic
   fun makeSegments(source: ByteString): ByteString {
     val buffer = Buffer()
     for (i in 0 until source.size) {
       val segment = buffer.writableSegment(SEGMENT_SIZE)
       segment.data[segment.pos] = source[i]
       segment.limit++
       buffer.size++
     }
     return buffer.snapshot()
   }

   /** Remove all segments from the pool and return them as a list. */
   @JvmStatic
   internal fun takeAllPoolSegments(): List<Segment> {
     val result = mutableListOf<Segment>()
     while (SegmentPool.byteCount > 0) {
       result += SegmentPool.take()
     }
     return result
   }

   /** Returns a copy of `buffer` with no segments with `original`.  */
   @JvmStatic
   fun deepCopy(original: Buffer): Buffer {
     val result = Buffer()
     if (original.size == 0L) return result

     result.head = original.head!!.unsharedCopy()
     result.head!!.prev = result.head
     result.head!!.next = result.head!!.prev
     var s = original.head!!.next
     while (s !== original.head) {
       result.head!!.prev!!.push(s!!.unsharedCopy())
       s = s.next
     }
     result.size = original.size

     return result
   }

   @JvmStatic
   fun Int.reverseBytes(): Int {
     /* ktlint-disable no-multi-spaces indent */
     return (this and -0x1000000 ushr 24) or
       (this and 0x00ff0000 ushr  8) or
       (this and 0x0000ff00  shl  8) or
       (this and 0x000000ff  shl 24)
     /* ktlint-enable no-multi-spaces indent */
   }

   @JvmStatic
   fun Short.reverseBytes(): Short {
     val i = toInt() and 0xffff
     /* ktlint-disable no-multi-spaces indent */
     val reversed = (i and 0xff00 ushr 8) or
       (i and 0x00ff  shl 8)
     /* ktlint-enable no-multi-spaces indent */
     return reversed.toShort()
   }

   fun assumeNotWindows() = Assume.assumeFalse(System.getProperty("os.name").toLowerCase().contains("win"))
 }
	/*
	* Copyright (C) 2014 Square, Inc.
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/
	package okio

	import okio.ByteString.Companion.encodeUtf8
	import org.junit.Assume
	import java.io.IOException
	import java.io.ObjectInputStream
	import java.io.ObjectOutputStream
	import java.io.Serializable
	import java.util.Random
	import kotlin.test.assertEquals
	import kotlin.test.assertFalse
	import kotlin.test.assertTrue

	object TestUtil {
	// Necessary to make an internal member visible to Java.
	@JvmField val SEGMENT_POOL_MAX_SIZE = SegmentPool.MAX_SIZE
	const val SEGMENT_SIZE = Segment.SIZE
	const val REPLACEMENT_CODE_POINT: Int = okio.REPLACEMENT_CODE_POINT

	@JvmStatic fun segmentPoolByteCount() = SegmentPool.byteCount

	@JvmStatic
	fun segmentSizes(buffer: Buffer): List<Int> = okio.segmentSizes(buffer)

	@JvmStatic
	fun assertNoEmptySegments(buffer: Buffer) {
	assertTrue(segmentSizes(buffer).all { it != 0 }, "Expected all segments to be non-empty")
	}

	@JvmStatic
	fun assertByteArraysEquals(a: ByteArray, b: ByteArray) {
	assertEquals(a.contentToString(), b.contentToString())
	}

	@JvmStatic
	fun assertByteArrayEquals(expectedUtf8: String, b: ByteArray) {
	assertEquals(expectedUtf8, b.toString(Charsets.UTF_8))
	}

	@JvmStatic
	fun randomBytes(length: Int): ByteString {
	val random = Random(0)
	val randomBytes = ByteArray(length)
	random.nextBytes(randomBytes)
	return ByteString.of(*randomBytes)
	}

	@JvmStatic
	fun randomSource(size: Long): Source {
	return object : Source {
	internal var random = Random(0)
	internal var bytesLeft = size
	internal var closed: Boolean = false

	@Throws(IOException::class)
	override fun read(sink: Buffer, byteCount: Long): Long {
	var byteCount = byteCount
	if (closed) throw IllegalStateException("closed")
	if (bytesLeft == 0L) return -1L
	if (byteCount > bytesLeft) byteCount = bytesLeft

	// If we can read a full segment we can save a copy.
	if (byteCount >= Segment.SIZE) {
	val segment = sink.writableSegment(Segment.SIZE)
	random.nextBytes(segment.data)
	segment.limit += Segment.SIZE
	sink.size += Segment.SIZE.toLong()
	bytesLeft -= Segment.SIZE.toLong()
	return Segment.SIZE.toLong()
	} else {
	val data = ByteArray(byteCount.toInt())
	random.nextBytes(data)
	sink.write(data)
	bytesLeft -= byteCount
	return byteCount
	}
	}

	override fun timeout() = Timeout.NONE

	@Throws(IOException::class)
	override fun close() {
	closed = true
	}
	}
	}

	@JvmStatic
	fun assertEquivalent(b1: ByteString, b2: ByteString) {
	// Equals.
	assertTrue(b1 == b2)
	assertTrue(b1 == b1)
	assertTrue(b2 == b1)

	// Hash code.
	assertEquals(b1.hashCode().toLong(), b2.hashCode().toLong())
	assertEquals(b1.hashCode().toLong(), b1.hashCode().toLong())
	assertEquals(b1.toString(), b2.toString())

	// Content.
	assertEquals(b1.size.toLong(), b2.size.toLong())
	val b2Bytes = b2.toByteArray()
	for (i in b2Bytes.indices) {
	val b = b2Bytes[i]
	assertEquals(b.toLong(), b1[i].toLong())
	}
	assertByteArraysEquals(b1.toByteArray(), b2Bytes)

	// Doesn't equal a different byte string.
	assertFalse(b1 == null)
	assertFalse(b1 == Any())
	if (b2Bytes.size > 0) {
	val b3Bytes = b2Bytes.clone()
	b3Bytes[b3Bytes.size - 1]++
	val b3 = ByteString(b3Bytes)
	assertFalse(b1 == b3)
	assertFalse(b1.hashCode() == b3.hashCode())
	} else {
	val b3 = "a".encodeUtf8()
	assertFalse(b1 == b3)
	assertFalse(b1.hashCode() == b3.hashCode())
	}
	}

	@JvmStatic
	fun assertEquivalent(b1: Buffer, b2: Buffer) {
	// Equals.
	assertTrue(b1 == b2)
	assertTrue(b1 == b1)
	assertTrue(b2 == b1)

	// Hash code.
	assertEquals(b1.hashCode().toLong(), b2.hashCode().toLong())
	assertEquals(b1.hashCode().toLong(), b1.hashCode().toLong())
	assertEquals(b1.toString(), b2.toString())

	// Content.
	assertEquals(b1.size, b2.size)
	val buffer = Buffer()
	b2.copyTo(buffer, 0, b2.size)
	val b2Bytes = b2.readByteArray()
	for (i in b2Bytes.indices) {
	val b = b2Bytes[i]
	assertEquals(b.toLong(), b1[i.toLong()].toLong())
	}

	// Doesn't equal a different buffer.
	assertFalse(b1 == Any())
	if (b2Bytes.size > 0) {
	val b3Bytes = b2Bytes.clone()
	b3Bytes[b3Bytes.size - 1]++
	val b3 = Buffer().write(b3Bytes)
	assertFalse(b1 == b3)
	assertFalse(b1.hashCode() == b3.hashCode())
	} else {
	val b3 = Buffer().writeUtf8("a")
	assertFalse(b1 == b3)
	assertFalse(b1.hashCode() == b3.hashCode())
	}
	}

	/** Serializes original to bytes, then deserializes those bytes and returns the result. */
	@Suppress("UNCHECKED_CAST")
	@Throws(Exception::class)
	@JvmStatic
	// Assume serialization doesn't change types.
	fun <T : Serializable> reserialize(original: T): T {
	val buffer = Buffer()
	val out = ObjectOutputStream(buffer.outputStream())
	out.writeObject(original)
	val input = ObjectInputStream(buffer.inputStream())
	return input.readObject() as T
	}

	/**
	* Returns a new buffer containing the data in `data` and a segment
	* layout determined by `dice`.
	*/
	@Throws(IOException::class)
	@JvmStatic
	fun bufferWithRandomSegmentLayout(dice: Random, data: ByteArray): Buffer {
	val result = Buffer()

	// Writing to result directly will yield packed segments. Instead, write to
	// other buffers, then write those buffers to result.
	var pos = 0
	var byteCount: Int
	while (pos < data.size) {
	byteCount = Segment.SIZE / 2 + dice.nextInt(Segment.SIZE / 2)
	if (byteCount > data.size - pos) byteCount = data.size - pos
	val offset = dice.nextInt(Segment.SIZE - byteCount)

	val segment = Buffer()
	segment.write(ByteArray(offset))
	segment.write(data, pos, byteCount)
	segment.skip(offset.toLong())

	result.write(segment, byteCount.toLong())
	pos += byteCount
	}

	return result
	}

	/**
	* Returns a new buffer containing the contents of `segments`, attempting to isolate each
	* string to its own segment in the returned buffer. This clones buffers so that segments are
	* shared, preventing compaction from occurring.
	*/
	@Throws(Exception::class)
	@JvmStatic
	fun bufferWithSegments(vararg segments: String): Buffer {
	val result = Buffer()
	for (s in segments) {
	val offsetInSegment = if (s.length < Segment.SIZE) (Segment.SIZE - s.length) / 2 else 0
	val buffer = Buffer()
	buffer.writeUtf8("_".repeat(offsetInSegment))
	buffer.writeUtf8(s)
	buffer.skip(offsetInSegment.toLong())
	result.write(buffer.clone(), buffer.size)
	}
	return result
	}

	@JvmStatic
	fun makeSegments(source: ByteString): ByteString {
	val buffer = Buffer()
	for (i in 0 until source.size) {
	val segment = buffer.writableSegment(SEGMENT_SIZE)
	segment.data[segment.pos] = source[i]
	segment.limit++
	buffer.size++
	}
	return buffer.snapshot()
	}

	/** Remove all segments from the pool and return them as a list. */
	@JvmStatic
	internal fun takeAllPoolSegments(): List<Segment> {
	val result = mutableListOf<Segment>()
	while (SegmentPool.byteCount > 0) {
	result += SegmentPool.take()
	}
	return result
	}

	/** Returns a copy of `buffer` with no segments with `original`. */
	@JvmStatic
	fun deepCopy(original: Buffer): Buffer {
	val result = Buffer()
	if (original.size == 0L) return result

	result.head = original.head!!.unsharedCopy()
	result.head!!.prev = result.head
	result.head!!.next = result.head!!.prev
	var s = original.head!!.next
	while (s !== original.head) {
	result.head!!.prev!!.push(s!!.unsharedCopy())
	s = s.next
	}
	result.size = original.size

	return result
	}

	@JvmStatic
	fun Int.reverseBytes(): Int {
	/* ktlint-disable no-multi-spaces indent */
	return (this and -0x1000000 ushr 24) or
	(this and 0x00ff0000 ushr 8) or
	(this and 0x0000ff00 shl 8) or
	(this and 0x000000ff shl 24)
	/* ktlint-enable no-multi-spaces indent */
	}

	@JvmStatic
	fun Short.reverseBytes(): Short {
	val i = toInt() and 0xffff
	/* ktlint-disable no-multi-spaces indent */
	val reversed = (i and 0xff00 ushr 8) or
	(i and 0x00ff shl 8)
	/* ktlint-enable no-multi-spaces indent */
	return reversed.toShort()
	}

	fun assumeNotWindows() = Assume.assumeFalse(System.getProperty("os.name").toLowerCase().contains("win"))
	}