for _, test := range containsReservedMetadataTests {
		t.Run("", func(t *testing.T) {
			contains := containsReservedMetadata(test.header)
			if contains && !test.shouldFail {
				t.Errorf("contains reserved header but should not fail")
			} else if !contains && test.shouldFail {
				t.Errorf("does not contain reserved header but failed")
			}
		})
	}
}

var sseTLSHandlerTests = []struct {

  }

  /**
   * Delegates to {@link Collection#contains}. Returns {@code false} if the {@code contains} method
   * throws a {@code ClassCastException} or {@code NullPointerException}.
   */
  static boolean safeContains(Collection<?> collection, @Nullable Object object) {
    checkNotNull(collection);
    try {
      return collection.contains(object);
    } catch (ClassCastException | NullPointerException e) {

    assertFalse(range.contains(4));
    assertTrue(range.contains(5));
    assertTrue(range.contains(7));
    assertFalse(range.contains(8));
  }

  public void testSingleton() {
    Range<Integer> range = Range.closed(4, 4);
    assertFalse(range.contains(3));
    assertTrue(range.contains(4));
    assertFalse(range.contains(5));
    assertTrue(range.hasLowerBound());

  }

  @Benchmark
  boolean contains(int reps) {
    // Paranoia: acting on hearsay that accessing fields might be slow
    // Should write a benchmark to test that!
    Set<Element> set = setToTest;
    Element[] queries = this.queries;

    int mask = queries.length - 1;

    boolean dummy = false;
    for (int i = 0; i < reps; i++) {
      dummy ^= set.contains(queries[i & mask]);
    }
    return dummy;
  }

    }

    @Test
    @DisplayName("toString contains key identifiers")
    void testToString() {
        SmbSessionImpl session = newSession();
        String s = session.toString();
        assertTrue(s.contains("targetHost=server.example"));
        assertTrue(s.contains("targetDomain=EXAMPLE"));
    }

    @Test

            () -> MathPreconditions.checkInRangeForRoundingInputs(false, 1.0, RoundingMode.UP));
    // b/38490623: The string contains "1.0" under most environment but just "1" under J2CL.
    assertThat(expected).hasMessageThat().contains("1");
    assertThat(expected).hasMessageThat().contains("UP");
  }

  public void testCheckNoOverflow_success() {

        assertNotNull(response.getWords());
        assertEquals(3, response.getWords().size());
        assertTrue(response.getWords().contains("apple"));
        assertTrue(response.getWords().contains("banana"));
        assertTrue(response.getWords().contains("cherry"));
    }

    @Test
    public void test_getNum() throws Exception {
        List<String> words = new ArrayList<>();
        words.add("word1");

        assertTrue(result instanceof FuzzyQueryBuilder);

        FuzzyQueryBuilder fuzzyQueryBuilder = (FuzzyQueryBuilder) result;

        assertTrue(fuzzyQueryBuilder.toString().contains("\"title\""));
        assertTrue(fuzzyQueryBuilder.toString().contains("\"fuzzy\""));
    }

    // Test convertFuzzyQuery with non-search field
    @Test
    public void test_convertFuzzyQuery_withNonSearchField() {

          for (int i = MIN_BOUND; i <= MAX_BOUND; i++) {
            Integer expectedValue = null;
            if (range1.contains(i)) {
              expectedValue = 1;
            } else if (range2.contains(i)) {
              expectedValue = 2;
            }

            assertEquals(expectedValue, rangeMap.get(i));
          }
        }
      }
    }
  }

        doThrow(new CIFSException("session key failure")).when(session).getSessionKey();

        CIFSException ex = assertThrows(CIFSException.class, () -> session.getSessionKey());
        assertTrue(ex.getMessage().contains("failure"));
        verify(session).getSessionKey();
    }

    // Happy path: transport is returned and verified
    @Test
    @DisplayName("getTransport returns mocked transport")
    void getTransport_happy() {