third-party/atomix/storage/src/test/java/io/atomix/storage/buffer/BufferTest.java

   1 /*
   2  * Copyright 2015-present Open Networking Foundation
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16 package io.atomix.storage.buffer;
  17
  18 import org.junit.Test;
  19
  20 import java.nio.BufferOverflowException;
  21 import java.nio.BufferUnderflowException;
  22 import java.nio.ByteOrder;
  23
  24 import static org.junit.Assert.assertEquals;
  25 import static org.junit.Assert.assertFalse;
  26 import static org.junit.Assert.assertTrue;
  27
  28 /**
  29  * Base buffer test.
  30  *
  31  * @author <a href="http://github.com/kuujo">Jordan Halterman</a>
  32  */
  33 public abstract class BufferTest {
  34
  35   /**
  36    * Creates a new test buffer.
  37    */
  38   protected abstract Buffer createBuffer(int capacity);
  39
  40   /**
  41    * Creates a new test buffer.
  42    */
  43   protected abstract Buffer createBuffer(int capacity, int maxCapacity);
  44
  45   @Test
  46   public void testPosition() {
  47     Buffer buffer = createBuffer(8);
  48     assertEquals(0, buffer.position());
  49     buffer.writeInt(10);
  50     assertEquals(4, buffer.position());
  51     buffer.position(0);
  52     assertEquals(0, buffer.position());
  53     assertEquals(10, buffer.readInt());
  54   }
  55
  56   @Test
  57   public void testFlip() {
  58     Buffer buffer = createBuffer(8);
  59     buffer.writeInt(10);
  60     assertEquals(4, buffer.position());
  61     assertEquals(8, buffer.capacity());
  62     assertEquals(-1, buffer.limit());
  63     assertEquals(8, buffer.capacity());
  64     buffer.flip();
  65     assertEquals(4, buffer.limit());
  66     assertEquals(0, buffer.position());
  67   }
  68
  69   @Test
  70   public void testLimit() {
  71     Buffer buffer = createBuffer(8);
  72     assertEquals(0, buffer.position());
  73     assertEquals(-1, buffer.limit());
  74     assertEquals(8, buffer.capacity());
  75     buffer.limit(4);
  76     assertEquals(4, buffer.limit());
  77     assertTrue(buffer.hasRemaining());
  78     buffer.writeInt(10);
  79     assertEquals(0, buffer.remaining());
  80     assertFalse(buffer.hasRemaining());
  81   }
  82
  83   @Test
  84   public void testClear() {
  85     Buffer buffer = createBuffer(8);
  86     buffer.limit(6);
  87     assertEquals(6, buffer.limit());
  88     buffer.writeInt(10);
  89     assertEquals(4, buffer.position());
  90     buffer.clear();
  91     assertEquals(-1, buffer.limit());
  92     assertEquals(8, buffer.capacity());
  93     assertEquals(0, buffer.position());
  94   }
  95
  96   @Test
  97   public void testMarkReset() {
  98     assertTrue(createBuffer(12).writeInt(10).mark().writeBoolean(true).reset().readBoolean());
  99   }
 100
 101   @Test(expected = BufferUnderflowException.class)
 102   public void testReadIntThrowsBufferUnderflowWithNoRemainingBytesRelative() {
 103     createBuffer(4, 4)
 104       .writeInt(10)
 105       .readInt();
 106   }
 107
 108   @Test(expected = BufferUnderflowException.class)
 109   public void testReadIntThrowsBufferUnderflowWithNoRemainingBytesAbsolute() {
 110     createBuffer(4, 4).readInt(2);
 111   }
 112
 113   @Test(expected = BufferOverflowException.class)
 114   public void testWriteIntThrowsBufferOverflowWithNoRemainingBytesRelative() {
 115     createBuffer(4, 4).writeInt(10).writeInt(20);
 116   }
 117
 118   @Test(expected = BufferOverflowException.class)
 119   public void testReadIntThrowsBufferOverflowWithNoRemainingBytesAbsolute() {
 120     createBuffer(4, 4).writeInt(4, 10);
 121   }
 122
 123   @Test(expected = IndexOutOfBoundsException.class)
 124   public void testReadIntThrowsIndexOutOfBounds() {
 125     createBuffer(4, 4).readInt(10);
 126   }
 127
 128   @Test(expected = IndexOutOfBoundsException.class)
 129   public void testWriteIntThrowsIndexOutOfBounds() {
 130     createBuffer(4, 4).writeInt(10, 10);
 131   }
 132
 133   @Test
 134   public void testWriteReadByteRelative() {
 135     assertEquals(10, createBuffer(16).writeByte(10).flip().readByte());
 136   }
 137
 138   @Test
 139   public void testWriteReadByteAbsolute() {
 140     assertEquals(10, createBuffer(16).writeByte(4, 10).readByte(4));
 141   }
 142
 143   @Test
 144   public void testWriteReadUnsignedByteRelative() {
 145     assertEquals(10, createBuffer(16).writeUnsignedByte(10).flip().readUnsignedByte());
 146   }
 147
 148   @Test
 149   public void testWriteReadUnsignedByteAbsolute() {
 150     assertEquals(10, createBuffer(16).writeUnsignedByte(4, 10).readUnsignedByte(4));
 151   }
 152
 153   @Test
 154   public void testWriteReadShortRelative() {
 155     assertEquals(10, createBuffer(16).writeShort((short) 10).flip().readShort());
 156   }
 157
 158   @Test
 159   public void testWriteReadShortAbsolute() {
 160     assertEquals(10, createBuffer(16).writeShort(4, (short) 10).readShort(4));
 161   }
 162
 163   @Test
 164   public void testWriteReadUnsignedShortRelative() {
 165     assertEquals(10, createBuffer(16).writeUnsignedShort((short) 10).flip().readUnsignedShort());
 166   }
 167
 168   @Test
 169   public void testWriteReadUnsignedShortAbsolute() {
 170     assertEquals(10, createBuffer(16).writeUnsignedShort(4, (short) 10).readUnsignedShort(4));
 171   }
 172
 173   @Test
 174   public void testWriteReadIntRelative() {
 175     assertEquals(10, createBuffer(16).writeInt(10).flip().readInt());
 176   }
 177
 178   @Test
 179   public void testWriteReadUnsignedIntAbsolute() {
 180     assertEquals(10, createBuffer(16).writeUnsignedInt(4, 10).readUnsignedInt(4));
 181   }
 182
 183   @Test
 184   public void testWriteReadUnsignedIntRelative() {
 185     assertEquals(10, createBuffer(16).writeUnsignedInt(10).flip().readUnsignedInt());
 186   }
 187
 188   @Test
 189   public void testWriteReadIntAbsolute() {
 190     assertEquals(10, createBuffer(16).writeInt(4, 10).readInt(4));
 191   }
 192
 193   @Test
 194   public void testWriteReadLongRelative() {
 195     assertEquals(12345, createBuffer(16).writeLong(12345).flip().readLong());
 196   }
 197
 198   @Test
 199   public void testWriteReadLongAbsolute() {
 200     assertEquals(12345, createBuffer(16).writeLong(4, 12345).readLong(4));
 201   }
 202
 203   @Test
 204   public void testWriteReadFloatRelative() {
 205     assertEquals(10.6f, createBuffer(16).writeFloat(10.6f).flip().readFloat(), .001);
 206   }
 207
 208   @Test
 209   public void testWriteReadFloatAbsolute() {
 210     assertEquals(10.6f, createBuffer(16).writeFloat(4, 10.6f).readFloat(4), .001);
 211   }
 212
 213   @Test
 214   public void testWriteReadDoubleRelative() {
 215     assertEquals(10.6, createBuffer(16).writeDouble(10.6).flip().readDouble(), .001);
 216   }
 217
 218   @Test
 219   public void testWriteReadDoubleAbsolute() {
 220     assertEquals(10.6, createBuffer(16).writeDouble(4, 10.6).readDouble(4), .001);
 221   }
 222
 223   @Test
 224   public void testWriteReadBooleanRelative() {
 225     assertTrue(createBuffer(16).writeBoolean(true).flip().readBoolean());
 226   }
 227
 228   @Test
 229   public void testWriteReadBooleanAbsolute() {
 230     assertTrue(createBuffer(16).writeBoolean(4, true).readBoolean(4));
 231   }
 232
 233   @Test
 234   public void testWriteReadStringRelative() {
 235     Buffer buffer = createBuffer(38)
 236         .writeString("Hello world!")
 237         .writeString("Hello world again!")
 238         .flip();
 239     assertEquals("Hello world!", buffer.readString());
 240     assertEquals("Hello world again!", buffer.readString());
 241   }
 242
 243   @Test
 244   public void testWriteReadStringAbsolute() {
 245     Buffer buffer = createBuffer(46)
 246         .writeString(4, "Hello world!")
 247         .writeString(20, "Hello world again!");
 248     assertEquals("Hello world!", buffer.readString(4));
 249     assertEquals("Hello world again!", buffer.readString(20));
 250   }
 251
 252   @Test
 253   public void testWriteReadUTF8Relative() {
 254     Buffer buffer = createBuffer(38)
 255         .writeUTF8("Hello world!")
 256         .writeUTF8("Hello world again!")
 257         .flip();
 258     assertEquals("Hello world!", buffer.readUTF8());
 259     assertEquals("Hello world again!", buffer.readUTF8());
 260   }
 261
 262   @Test
 263   public void testWriteReadUTF8Absolute() {
 264     Buffer buffer = createBuffer(46)
 265         .writeUTF8(4, "Hello world!")
 266         .writeUTF8(20, "Hello world again!");
 267     assertEquals("Hello world!", buffer.readUTF8(4));
 268     assertEquals("Hello world again!", buffer.readUTF8(20));
 269   }
 270
 271   @Test
 272   public void testReadWriter() {
 273     Buffer writeBuffer = createBuffer(8).writeLong(10).flip();
 274     Buffer readBuffer = createBuffer(8);
 275     writeBuffer.read(readBuffer);
 276     assertEquals(10, readBuffer.flip().readLong());
 277   }
 278
 279   @Test
 280   public void testWriteReadSwappedIntRelative() {
 281     assertEquals(10, createBuffer(16).order(ByteOrder.LITTLE_ENDIAN).writeInt(10).flip().readInt());
 282   }
 283
 284   @Test
 285   public void testWriteReadSwappedIntAbsolute() {
 286     assertEquals(10, createBuffer(16).order(ByteOrder.LITTLE_ENDIAN).writeInt(4, 10).readInt(4));
 287   }
 288
 289   @Test
 290   public void testAbsoluteSlice() {
 291     Buffer buffer = createBuffer(1024);
 292     buffer.writeLong(10).writeLong(11).rewind();
 293     Buffer slice = buffer.slice(8, 1016);
 294     assertEquals(0, slice.position());
 295     assertEquals(11, slice.readLong());
 296   }
 297
 298   @Test
 299   public void testRelativeSliceWithoutLength() {
 300     Buffer buffer = createBuffer(1024, 1024);
 301     buffer.writeLong(10).writeLong(11).writeLong(12).rewind();
 302     assertEquals(10, buffer.readLong());
 303     Buffer slice = buffer.slice();
 304     assertEquals(0, slice.position());
 305     assertEquals(-1, slice.limit());
 306     assertEquals(1016, slice.capacity());
 307     assertEquals(1016, slice.maxCapacity());
 308     assertEquals(11, slice.readLong());
 309     assertEquals(11, slice.readLong(0));
 310     slice.close();
 311     Buffer slice2 = buffer.skip(8).slice();
 312     assertEquals(0, slice2.position());
 313     assertEquals(-1, slice2.limit());
 314     assertEquals(1008, slice2.capacity());
 315     assertEquals(1008, slice2.maxCapacity());
 316     assertEquals(12, slice2.readLong());
 317     assertEquals(12, slice2.readLong(0));
 318   }
 319
 320   @Test
 321   public void testRelativeSliceWithLength() {
 322     Buffer buffer = createBuffer(1024);
 323     buffer.writeLong(10).writeLong(11).writeLong(12).rewind();
 324     assertEquals(10, buffer.readLong());
 325     Buffer slice = buffer.slice(8);
 326     assertEquals(0, slice.position());
 327     assertEquals(11, slice.readLong());
 328     assertEquals(11, slice.readLong(0));
 329     slice.close();
 330     Buffer slice2 = buffer.skip(8).slice(8);
 331     assertEquals(0, slice2.position());
 332     assertEquals(12, slice2.readLong());
 333     assertEquals(12, slice2.readLong(0));
 334     slice2.close();
 335   }
 336
 337   @Test
 338   public void testSliceOfSlice() {
 339     Buffer buffer = createBuffer(1024);
 340     buffer.writeLong(10).writeLong(11).writeLong(12).rewind();
 341     assertEquals(10, buffer.readLong());
 342     Buffer slice = buffer.slice();
 343     assertEquals(11, slice.readLong());
 344     Buffer sliceOfSlice = slice.slice();
 345     assertEquals(12, sliceOfSlice.readLong());
 346     assertEquals(8, sliceOfSlice.position());
 347   }
 348
 349   @Test
 350   public void testSliceWithLimit() {
 351     Buffer buffer = createBuffer(1024).limit(16);
 352     buffer.writeLong(10);
 353     Buffer slice = buffer.slice();
 354     assertEquals(0, slice.position());
 355     assertEquals(8, slice.capacity());
 356     assertEquals(8, slice.maxCapacity());
 357     assertEquals(8, slice.remaining());
 358   }
 359
 360   @Test
 361   public void testSliceWithLittleRemaining() {
 362     Buffer buffer = createBuffer(1024, 2048);
 363     buffer.position(1020);
 364     Buffer slice = buffer.slice(8);
 365     assertEquals(0, slice.position());
 366     assertEquals(-1, slice.limit());
 367   }
 368
 369   @Test
 370   public void testCompact() {
 371     Buffer buffer = createBuffer(1024);
 372     buffer.position(100).writeLong(1234).position(100).compact();
 373     assertEquals(0, buffer.position());
 374     assertEquals(1234, buffer.readLong());
 375   }
 376
 377   @Test
 378   public void testSwappedPosition() {
 379     Buffer buffer = createBuffer(8).order(ByteOrder.LITTLE_ENDIAN);
 380     assertEquals(0, buffer.position());
 381     buffer.writeInt(10);
 382     assertEquals(4, buffer.position());
 383     buffer.position(0);
 384     assertEquals(0, buffer.position());
 385     assertEquals(10, buffer.readInt());
 386   }
 387
 388   @Test
 389   public void testSwappedFlip() {
 390     Buffer buffer = createBuffer(8).order(ByteOrder.LITTLE_ENDIAN);
 391     buffer.writeInt(10);
 392     assertEquals(4, buffer.position());
 393     assertEquals(8, buffer.capacity());
 394     assertEquals(-1, buffer.limit());
 395     assertEquals(8, buffer.capacity());
 396     buffer.flip();
 397     assertEquals(4, buffer.limit());
 398     assertEquals(0, buffer.position());
 399   }
 400
 401   @Test
 402   public void testSwappedLimit() {
 403     Buffer buffer = createBuffer(8).order(ByteOrder.LITTLE_ENDIAN);
 404     assertEquals(0, buffer.position());
 405     assertEquals(-1, buffer.limit());
 406     assertEquals(8, buffer.capacity());
 407     buffer.limit(4);
 408     assertEquals(4, buffer.limit());
 409     assertTrue(buffer.hasRemaining());
 410     buffer.writeInt(10);
 411     assertEquals(0, buffer.remaining());
 412     assertFalse(buffer.hasRemaining());
 413   }
 414
 415   @Test
 416   public void testSwappedClear() {
 417     Buffer buffer = createBuffer(8).order(ByteOrder.LITTLE_ENDIAN);
 418     buffer.limit(6);
 419     assertEquals(6, buffer.limit());
 420     buffer.writeInt(10);
 421     assertEquals(4, buffer.position());
 422     buffer.clear();
 423     assertEquals(-1, buffer.limit());
 424     assertEquals(8, buffer.capacity());
 425     assertEquals(0, buffer.position());
 426   }
 427
 428   @Test
 429   public void testSwappedMarkReset() {
 430     assertTrue(createBuffer(12).order(ByteOrder.LITTLE_ENDIAN).writeInt(10).mark().writeBoolean(true).reset().readBoolean());
 431   }
 432
 433   @Test(expected = BufferUnderflowException.class)
 434   public void testSwappedReadIntThrowsBufferUnderflowWithNoRemainingBytesRelative() {
 435     createBuffer(4, 4).order(ByteOrder.LITTLE_ENDIAN)
 436       .writeInt(10)
 437       .readInt();
 438   }
 439
 440   @Test(expected = BufferUnderflowException.class)
 441   public void testSwappedReadIntThrowsBufferUnderflowWithNoRemainingBytesAbsolute() {
 442     createBuffer(4, 4).order(ByteOrder.LITTLE_ENDIAN).readInt(2);
 443   }
 444
 445   @Test(expected = BufferOverflowException.class)
 446   public void testSwappedWriteIntThrowsBufferOverflowWithNoRemainingBytesRelative() {
 447     createBuffer(4, 4).order(ByteOrder.LITTLE_ENDIAN).writeInt(10).writeInt(20);
 448   }
 449
 450   @Test(expected = BufferOverflowException.class)
 451   public void testSwappedReadIntThrowsBufferOverflowWithNoRemainingBytesAbsolute() {
 452     createBuffer(4, 4).order(ByteOrder.LITTLE_ENDIAN).writeInt(4, 10);
 453   }
 454
 455   @Test(expected = IndexOutOfBoundsException.class)
 456   public void testSwappedReadIntThrowsIndexOutOfBounds() {
 457     createBuffer(4, 4).order(ByteOrder.LITTLE_ENDIAN).readInt(10);
 458   }
 459
 460   @Test(expected = IndexOutOfBoundsException.class)
 461   public void testSwappedWriteIntThrowsIndexOutOfBounds() {
 462     createBuffer(4, 4).order(ByteOrder.LITTLE_ENDIAN).writeInt(10, 10);
 463   }
 464
 465   @Test
 466   public void testSwappedWriteReadByteRelative() {
 467     assertEquals(10, createBuffer(16).order(ByteOrder.LITTLE_ENDIAN).writeByte(10).flip().readByte());
 468   }
 469
 470   @Test
 471   public void testSwappedWriteReadByteAbsolute() {
 472     assertEquals(10, createBuffer(16).order(ByteOrder.LITTLE_ENDIAN).writeByte(4, 10).readByte(4));
 473   }
 474
 475   @Test
 476   public void testSwappedWriteReadUnsignedByteRelative() {
 477     assertEquals(10, createBuffer(16).order(ByteOrder.LITTLE_ENDIAN).writeUnsignedByte(10).flip().readUnsignedByte());
 478   }
 479
 480   @Test
 481   public void testSwappedWriteReadUnsignedByteAbsolute() {
 482     assertEquals(10, createBuffer(16).order(ByteOrder.LITTLE_ENDIAN).writeUnsignedByte(4, 10).readUnsignedByte(4));
 483   }
 484
 485   @Test
 486   public void testSwappedWriteReadShortRelative() {
 487     assertEquals(10, createBuffer(16).order(ByteOrder.LITTLE_ENDIAN).writeShort((short) 10).flip().readShort());
 488   }
 489
 490   @Test
 491   public void testSwappedWriteReadShortAbsolute() {
 492     assertEquals(10, createBuffer(16).order(ByteOrder.LITTLE_ENDIAN).writeShort(4, (short) 10).readShort(4));
 493   }
 494
 495   @Test
 496   public void testSwappedWriteReadUnsignedShortRelative() {
 497     assertEquals(10, createBuffer(16).order(ByteOrder.LITTLE_ENDIAN).writeUnsignedShort((short) 10).flip().readUnsignedShort());
 498   }
 499
 500   @Test
 501   public void testSwappedWriteReadUnsignedShortAbsolute() {
 502     assertEquals(10, createBuffer(16).order(ByteOrder.LITTLE_ENDIAN).writeUnsignedShort(4, (short) 10).readUnsignedShort(4));
 503   }
 504
 505   @Test
 506   public void testSwappedWriteReadIntRelative() {
 507     assertEquals(10, createBuffer(16).order(ByteOrder.LITTLE_ENDIAN).writeInt(10).flip().readInt());
 508   }
 509
 510   @Test
 511   public void testSwappedWriteReadUnsignedIntAbsolute() {
 512     assertEquals(10, createBuffer(16).order(ByteOrder.LITTLE_ENDIAN).writeUnsignedInt(4, 10).readUnsignedInt(4));
 513   }
 514
 515   @Test
 516   public void testSwappedWriteReadUnsignedIntRelative() {
 517     assertEquals(10, createBuffer(16).order(ByteOrder.LITTLE_ENDIAN).writeUnsignedInt(10).flip().readUnsignedInt());
 518   }
 519
 520   @Test
 521   public void testSwappedWriteReadIntAbsolute() {
 522     assertEquals(10, createBuffer(16).order(ByteOrder.LITTLE_ENDIAN).writeInt(4, 10).readInt(4));
 523   }
 524
 525   @Test
 526   public void testSwappedWriteReadLongRelative() {
 527     assertEquals(12345, createBuffer(16).order(ByteOrder.LITTLE_ENDIAN).writeLong(12345).flip().readLong());
 528   }
 529
 530   @Test
 531   public void testSwappedWriteReadLongAbsolute() {
 532     assertEquals(12345, createBuffer(16).order(ByteOrder.LITTLE_ENDIAN).writeLong(4, 12345).readLong(4));
 533   }
 534
 535   @Test
 536   public void testSwappedWriteReadFloatRelative() {
 537     assertEquals(10.6f, createBuffer(16).order(ByteOrder.LITTLE_ENDIAN).writeFloat(10.6f).flip().readFloat(), .001);
 538   }
 539
 540   @Test
 541   public void testSwappedWriteReadFloatAbsolute() {
 542     assertEquals(10.6f, createBuffer(16).order(ByteOrder.LITTLE_ENDIAN).writeFloat(4, 10.6f).readFloat(4), .001);
 543   }
 544
 545   @Test
 546   public void testSwappedWriteReadDoubleRelative() {
 547     assertEquals(10.6, createBuffer(16).order(ByteOrder.LITTLE_ENDIAN).writeDouble(10.6).flip().readDouble(), .001);
 548   }
 549
 550   @Test
 551   public void testSwappedWriteReadDoubleAbsolute() {
 552     assertEquals(10.6, createBuffer(16).order(ByteOrder.LITTLE_ENDIAN).writeDouble(4, 10.6).readDouble(4), .001);
 553   }
 554
 555   @Test
 556   public void testSwappedWriteReadBooleanRelative() {
 557     assertTrue(createBuffer(16).order(ByteOrder.LITTLE_ENDIAN).writeBoolean(true).flip().readBoolean());
 558   }
 559
 560   @Test
 561   public void testSwappedWriteReadBooleanAbsolute() {
 562     assertTrue(createBuffer(16).order(ByteOrder.LITTLE_ENDIAN).writeBoolean(4, true).readBoolean(4));
 563   }
 564
 565   @Test
 566   public void testSwappedReadWriter() {
 567     Buffer writeBuffer = createBuffer(8).order(ByteOrder.LITTLE_ENDIAN).writeLong(10).flip();
 568     Buffer readBuffer = createBuffer(8).order(ByteOrder.LITTLE_ENDIAN);
 569     writeBuffer.read(readBuffer);
 570     assertEquals(10, readBuffer.flip().readLong());
 571   }
 572
 573   @Test
 574   public void testSwappedAbsoluteSlice() {
 575     Buffer buffer = createBuffer(1024).order(ByteOrder.LITTLE_ENDIAN);
 576     buffer.writeLong(10).writeLong(11).rewind();
 577     Buffer slice = buffer.slice(8, 1016);
 578     assertEquals(0, slice.position());
 579     assertEquals(11, slice.readLong());
 580   }
 581
 582   @Test
 583   public void testSwappedRelativeSliceWithoutLength() {
 584     Buffer buffer = createBuffer(1024, 1024).order(ByteOrder.LITTLE_ENDIAN);
 585     buffer.writeLong(10).writeLong(11).writeLong(12).rewind();
 586     assertEquals(10, buffer.readLong());
 587     Buffer slice = buffer.slice();
 588     assertEquals(0, slice.position());
 589     assertEquals(-1, slice.limit());
 590     assertEquals(1016, slice.capacity());
 591     assertEquals(1016, slice.maxCapacity());
 592     assertEquals(11, slice.readLong());
 593     assertEquals(11, slice.readLong(0));
 594     slice.close();
 595     Buffer slice2 = buffer.skip(8).slice();
 596     assertEquals(0, slice2.position());
 597     assertEquals(-1, slice2.limit());
 598     assertEquals(1008, slice2.capacity());
 599     assertEquals(1008, slice2.maxCapacity());
 600     assertEquals(12, slice2.readLong());
 601     assertEquals(12, slice2.readLong(0));
 602   }
 603
 604   @Test
 605   public void testSwappedRelativeSliceWithLength() {
 606     Buffer buffer = createBuffer(1024).order(ByteOrder.LITTLE_ENDIAN);
 607     buffer.writeLong(10).writeLong(11).writeLong(12).rewind();
 608     assertEquals(10, buffer.readLong());
 609     Buffer slice = buffer.slice(8);
 610     assertEquals(0, slice.position());
 611     assertEquals(11, slice.readLong());
 612     assertEquals(11, slice.readLong(0));
 613     slice.close();
 614     Buffer slice2 = buffer.skip(8).slice(8);
 615     assertEquals(0, slice2.position());
 616     assertEquals(12, slice2.readLong());
 617     assertEquals(12, slice2.readLong(0));
 618     slice2.close();
 619   }
 620
 621   @Test
 622   public void testSwappedSliceOfSlice() {
 623     Buffer buffer = createBuffer(1024).order(ByteOrder.LITTLE_ENDIAN);
 624     buffer.writeLong(10).writeLong(11).writeLong(12).rewind();
 625     assertEquals(10, buffer.readLong());
 626     Buffer slice = buffer.slice();
 627     assertEquals(11, slice.readLong());
 628     Buffer sliceOfSlice = slice.slice();
 629     assertEquals(12, sliceOfSlice.readLong());
 630     assertEquals(8, sliceOfSlice.position());
 631   }
 632
 633   @Test
 634   public void testSwappedSliceWithLimit() {
 635     Buffer buffer = createBuffer(1024).order(ByteOrder.LITTLE_ENDIAN).limit(16);
 636     buffer.writeLong(10);
 637     Buffer slice = buffer.slice();
 638     assertEquals(0, slice.position());
 639     assertEquals(8, slice.capacity());
 640     assertEquals(8, slice.maxCapacity());
 641     assertEquals(8, slice.remaining());
 642   }
 643
 644   @Test
 645   public void testSwappedSliceWithLittleRemaining() {
 646     Buffer buffer = createBuffer(1024, 2048).order(ByteOrder.LITTLE_ENDIAN);
 647     buffer.position(1020);
 648     Buffer slice = buffer.slice(8);
 649     assertEquals(0, slice.position());
 650     assertEquals(-1, slice.limit());
 651   }
 652
 653   @Test
 654   public void testSwappedCompact() {
 655     Buffer buffer = createBuffer(1024).order(ByteOrder.LITTLE_ENDIAN);
 656     buffer.position(100).writeLong(1234).position(100).compact();
 657     assertEquals(0, buffer.position());
 658     assertEquals(1234, buffer.readLong());
 659   }
 660
 661   @Test
 662   public void testCapacity0Read() {
 663     Buffer buffer = createBuffer(0, 1024);
 664     assertEquals(0, buffer.readLong());
 665   }
 666
 667   @Test
 668   public void testCapacity0Write() {
 669     Buffer buffer = createBuffer(0, 1024);
 670     buffer.writeLong(10);
 671     assertEquals(10, buffer.readLong(0));
 672   }
 673
 674 }