) {
        exchange.noNewExchangesOnConnection()
      }
      if ((code == 204 || code == 205) && response.body.contentLength() > 0L) {
        throw ProtocolException(
          "HTTP $code had non-zero Content-Length: ${response.body.contentLength()}",
        )
      }
      return response
    } catch (e: IOException) {
      if (sendRequestException != null) {
        sendRequestException.addSuppressed(e)

        Smb2LeaseKey key = new Smb2LeaseKey(testBytes);

        assertArrayEquals(testBytes, key.getKey());
        assertFalse(key.isZero());
    }

    @Test
    @DisplayName("Should create zero lease key")
    void testZeroLeaseKey() {
        byte[] zeroBytes = new byte[16];
        Arrays.fill(zeroBytes, (byte) 0);

        Smb2LeaseKey key = new Smb2LeaseKey(zeroBytes);

        assertTrue(key.isZero());

        assertEquals(Relation.GREATER_THAN_OR_EQUAL_TO.toString(), result.getAllRecordCountRelation());
    }

    /**
     * Test SearchResult with zero record count.
     */
    @Test
    public void test_zeroRecordCount() {
        final SearchResult result = SearchResult.create().allRecordCount(0).build();

        assertEquals(0, result.getAllRecordCount());

	}

	if err := DB.Create(&users).Error; err != nil {
		t.Fatalf("errors happened when create: %v", err)
	} else if user.ID == 0 {
		t.Fatalf("user's primary value should not zero, %v", user.ID)
	} else if user.UpdatedAt.IsZero() {
		t.Fatalf("user's updated at should not zero, %v", user.UpdatedAt)
	}
	lastUpdatedAt = user.UpdatedAt

	if err := DB.Model(user).Update("Age", 10).Error; err != nil {
		t.Errorf("errors happened when update: %v", err)

import java.util.Arrays;
import java.util.Collection;
import java.util.Objects;
import org.jspecify.annotations.Nullable;

/**
 * Implementation of {@link ImmutableMultiset} with zero or more elements.
 *
 * @author Jared Levy
 * @author Louis Wasserman
 */
@GwtCompatible
@SuppressWarnings("serial") // uses writeReplace(), not default serialization

        assertThrows(Exception.class, () -> new Pac(pacData, keys));
    }

    @Test
    void testZeroBufferCount() throws IOException {
        // Test PAC with zero buffers (missing required buffers)
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        writeLittleEndianInt(baos, 0); // bufferCount = 0

        bufferIndex += 2;
        setupCount = buffer[bufferIndex] & 0xFF;
        bufferIndex += 2;
        if ((setupCount != 0) && (LogStream.level > 2)) {
            log.println("setupCount is not zero: " + setupCount);
        }

        return bufferIndex - start;
    }

    @Override
    int readBytesWireFormat(final byte[] buffer, int bufferIndex) {
        pad = pad1 = 0;
        final int n;

		{Action: NoneAction},
	}
	for i := range wantEvents {
		if gotEvents[i].Action != wantEvents[i].Action {
			t.Fatalf("test-%d: got %v, want %v", i+1, gotEvents[i], wantEvents[i])
		}
	}

	// Test with zero versions
	events, err := evaluator.Eval(nil)
	if len(events) != 0 || err != nil {
		t.Fatal("expected no events nor error")
	}
}

func TestEmptyEvaluator(t *testing.T) {
	var objs []ObjectOpts

        assertEquals(expected, format.formatProgress(progressedSize, -1L));
    }

    static Stream<Arguments> progressedSizeWithSizeTestData() {
        return Stream.of(
                // Zero test
                Arguments.of(0L, 0L, "0 B"),

                // Bytes tests
                Arguments.of(0L, 800L, "0/800 B"),
                Arguments.of(400L, 800L, "400/800 B"),

func (ps *PubSub[T, M]) Subscribers() int32 {
	return atomic.LoadInt32(&ps.numSubscribers)
}

// New inits a PubSub system with a limit of maximum
// subscribers unless zero is specified
func New[T Maskable, M Maskable](maxSubscribers int32) *PubSub[T, M] {
	return &PubSub[T, M]{maxSubscribers: maxSubscribers}