return new CompoundOrdering<>(this, checkNotNull(secondaryComparator));
  }

  /**
   * Returns an ordering which tries each given comparator in order until a non-zero result is
   * found, returning that result, and returning zero only if all comparators return zero. The
   * returned ordering is based on the state of the {@code comparators} iterable at the time it was
   * provided to this method.
   *

      // We're looking for the smallest charsPerChunk such that bitsPerChar * charsPerChunk is a
      // multiple of 8. A multiple of 8 has 3 low zero bits, so we just need to figure out how many
      // extra zero bits we need to add to the end of bitsPerChar to get 3 in total.
      // The logic here would be wrong for bitsPerChar > 8, but since we require distinct ASCII
      // characters that can't happen.

        when(messageBlock.getMid()).thenReturn(minMid);

        messageBlock.setMid(minMid);
        assertEquals(minMid, messageBlock.getMid());

        // Test with zero
        long zeroMid = 0L;
        doNothing().when(messageBlock).setMid(zeroMid);
        when(messageBlock.getMid()).thenReturn(zeroMid);

        messageBlock.setMid(zeroMid);

        assertEquals(0, response.readDataWireFormat(largeBuffer, 0, 65536));
    }

    @Test
    @DisplayName("Test boundary conditions for read methods with zero length")
    void testReadMethodsWithZeroLength() {
        // Arrange
        byte[] buffer = new byte[100];

        // Act & Assert
        assertEquals(0, response.readSetupWireFormat(buffer, 0, 0));

        char[] decrypted = storage.decryptCredentials(encrypted);
        assertNotNull(decrypted, "Decrypted empty data should not be null");
        assertEquals(0, decrypted.length, "Decrypted empty array should have zero length");
    }

    @Test
    public void testEncryptDecryptNull() throws Exception {
        byte[] encrypted = storage.encryptCredentials(null);
        assertNull(encrypted, "Encrypting null should return null");

                return emptyMap();
              }
            })
        .named("emptyMap")
        .withFeatures(CollectionFeature.SERIALIZABLE, CollectionSize.ZERO)
        .suppressing(suppressForEmptyMap())
        .createTestSuite();
  }

  public Test testsForSingletonMap() {
    return MapTestSuiteBuilder.using(
            new TestStringMapGenerator() {

   * For example, if {@code end = next(next(next(start)))}, then {@code distance(start, end) == 3}
   * and {@code distance(end, start) == -3}. As well, {@code distance(a, a)} is always zero.
   *
   * <p>Note that this function is necessarily well-defined for any discrete type.
   *
   * @return the distance as described above, or {@link Long#MIN_VALUE} or {@link Long#MAX_VALUE} if

      checkZeroElements(q);
    }
  }

  private void checkZeroElements(BlockingQueue<Object> q) throws InterruptedException {
    for (boolean interruptibly : new boolean[] {true, false}) {
      // asking to drain zero elements
      assertEquals(0, drain(q, ImmutableList.of(), 0, 10, MILLISECONDS, interruptibly));
    }
  }

  public void testEmpty() throws Exception {
    for (BlockingQueue<Object> q : blockingQueues()) {

		cr.err = errSignatureMismatch
		return n, cr.err
	}
	cr.seedSignature = newSignature
	cr.chunkSHA256Writer.Reset()

	// If the chunk size is zero we return io.EOF. As specified by AWS,
	// only the last chunk is zero-sized.
	if len(cr.buffer) == 0 {
		if cr.debug {
			fmt.Println("EOF. Reading Trailers:", cr.trailers)
		}
		if cr.trailers != nil {
			err = cr.readTrailers()

        }

        @ParameterizedTest
        @ValueSource(longs = { 1L, 100L, Long.MAX_VALUE })
        @DisplayName("isResponseAsync should return true for various non-zero asyncIds")
        void testIsResponseAsyncWithDifferentValues(long asyncId) {
            testRequest.setAsyncId(asyncId);
            assertTrue(testRequest.isResponseAsync());
        }
    }

    @Nested