ByteStreams.copy(in, out);
    in.close();
    out.close();

    assertTrue(source.wasStreamClosed());
    assertArrayEquals(bytes, out.toByteArray());
  }

  public void testSize() throws IOException {
    assertEquals(bytes.length, source.size());
    assertTrue(source.wasStreamOpened() && source.wasStreamClosed());

    // test that we can get the size even if skip() isn't supported

            assertArrayEquals(testName, nameCheck);
        }

        @Test
        @DisplayName("Should return correct size")
        void testSize() {
            int size = testRequest.size();
            assertTrue(size > 0);
            assertEquals(testName.length + 16, size);
            assertEquals(1, testRequest.getSizeCallCount());
        }

    assertThrows(IllegalStateException.class, () -> iterator.remove());
  }

  public void testSize0() {
    Iterator<String> iterator = emptyIterator();
    assertEquals(0, Iterators.size(iterator));
  }

  public void testSize1() {
    Iterator<Integer> iterator = singleton(0).iterator();
    assertEquals(1, Iterators.size(iterator));
  }

                Arguments.of(15L * 1000L * 1000L * 1000L, "15 GB"),
                Arguments.of(1000L * 1000L * 1000L * 1000L, "1000 GB"));
    }

    @ParameterizedTest
    @MethodSource("sizeTestData")
    void testSize(long input, String expected) {
        FileSizeFormat format = new FileSizeFormat();
        assertEquals(expected, format.format(input));
    }

    static Stream<Arguments> sizeWithScaleUnitTestData() {

        assertTrue(response instanceof Smb2TreeConnectResponse);
        verify(mockContext, times(1)).getConfig();
    }

    @Test
    @DisplayName("Should calculate correct message size for different paths")
    void testSize() {
        // Given
        String shortPath = "\\\\a\\b";
        String longPath = "\\\\server.domain.com\\very_long_share_name_here";

        // Verify response has correct fileName
        assertEquals(testFileName, response.getFileName());
    }

    @Test
    @DisplayName("size should return correct message size")
    void testSize() {
        int expectedSize = Smb2Constants.SMB2_HEADER_LENGTH + 24;
        // size8 method rounds up to 8-byte boundary
        int expectedAlignedSize = (expectedSize + 7) & ~7;

        }
    }

    @Nested
    @DisplayName("Size Calculation Tests")
    class SizeCalculationTests {

        @Test
        @DisplayName("Should calculate size correctly")
        void testSize() {
            int expectedSize = ((Smb2Constants.SMB2_HEADER_LENGTH + 49 + 7) / 8) * 8;
            assertEquals(expectedSize, request.size());
        }

        @Test

    assertThrows(IllegalStateException.class, () -> iterator.remove());
  }

  public void testSize0() {
    Iterator<String> iterator = emptyIterator();
    assertEquals(0, Iterators.size(iterator));
  }

  public void testSize1() {
    Iterator<Integer> iterator = singleton(0).iterator();
    assertEquals(1, Iterators.size(iterator));
  }

     * applicable for the arguments (Predicate<FluentIterableTest.X>)
     */
    // FluentIterable.of().append(aIterable).append(bIterable).filter(xPredicate);
  }

  public void testSize0() {
    assertEquals(0, FluentIterable.<String>of().size());
  }

  public void testSize1Collection() {
    assertEquals(1, FluentIterable.from(asList("a")).size());
  }

      assertEquals(initialSize, map.size());
    } else {
      assertThrows(UnsupportedOperationException.class, () -> map.remove(keyToRemove));
    }
    assertInvariants(map);
  }

  public void testSize() {
    assertInvariants(makeEitherMap());
  }

  public void testKeySetRemove() {
    Map<K, V> map;
    try {
      map = makePopulatedMap();
    } catch (UnsupportedOperationException e) {