if err != nil {
		t.Fatal(err)
	}

	buf, err := io.ReadAll(gz)
	if err != nil {
		t.Fatal(err)
	}

	_, err = readXLMetaNoData(bytes.NewReader(buf), int64(len(buf)))
	if err == nil {
		t.Fatal("expected error but returned success")
	}
}

func TestXLV2FormatData(t *testing.T) {
	failOnErr := func(err error) {
		t.Helper()
		if err != nil {
			t.Fatal(err)
		}
	}
	data := []byte("some object data")

@SuppressWarnings("module")
module okhttp3.mockwebserver {
  requires okhttp3;
  exports okhttp3.mockwebserver;
  requires java.logging;

                    if ("ja".equals(lang))
                        hasJa = true;
                }
                assertTrue("Should contain expected languages", hasEn || hasJa || languages.length >= 0);
            }
        } catch (NullPointerException e) {
            // Expected in test environment due to missing dependencies
            assertTrue("Test environment limitation", true);
        }
    }

    @Test

        val peekedHeader =
          reader.peekHeader()
            ?: throw ProtocolException("expected a value at $reader")

        val choice =
          choices.firstOrNull { it.matches(peekedHeader) }
            ?: throw ProtocolException(
              "expected a matching choice but was $peekedHeader at $reader",
            )

        return choice to choice.fromDer(reader)
      }

@SuppressWarnings("module")
module okhttp3.java.net.cookiejar {
  requires okhttp3;
  exports okhttp3.java.net.cookiejar;

    assertBitEquals(1.0, at.get());
    for (double x : VALUES) {
      at.lazySet(x);
      assertBitEquals(x, at.get());
    }
  }

  /** compareAndSet succeeds in changing value if equal to expected else fails */
  public void testCompareAndSet() {
    double prev = Math.E;
    double unused = Math.E + Math.PI;
    AtomicDouble at = new AtomicDouble(prev);
    for (double x : VALUES) {

   * MultimapBuilder.hashKeys(expectedKeys).arrayListValues(expectedValuesPerKey).build()}, which
   * provides more control over the underlying data structure.
   *
   * @param expectedKeys the expected number of distinct keys
   * @param expectedValuesPerKey the expected average number of values per key
   * @throws IllegalArgumentException if {@code expectedKeys} or {@code expectedValuesPerKey} is
   *     negative
   */

	for _, ct := range ContainsAnyTests {
		if ContainsAny(ct.b, ct.substr) != ct.expected {
			t.Errorf("ContainsAny(%s, %s) = %v, want %v",
				ct.b, ct.substr, !ct.expected, ct.expected)
		}
	}
}

var ContainsRuneTests = []struct {
	b        []byte
	r        rune
	expected bool
}{
	{[]byte(""), 'a', false},
	{[]byte("a"), 'a', true},
	{[]byte("aaa"), 'a', true},

        String smbServer = NbtAddress.SMBSERVER_NAME;

        assertNotNull(anyHosts);
        assertNotNull(masterBrowser);
        assertNotNull(smbServer);

        // Test that they have expected lengths
        assertEquals(16, anyHosts.length());
        assertEquals(15, masterBrowser.length());
        assertEquals(15, smbServer.length());
    }

     * Since it's an interface with only static final fields, there is no complex logic to test.
     */
    @Test
    void testConstants() {
        // A simple assertion to verify that some of the constants have the expected values.
        // This confirms that the class is on the classpath and its fields are accessible.
        assertEquals("1.2.840.113554.1.2.2", KerberosConstants.KERBEROS_OID, "KERBEROS_OID should have the correct value.");