gotSource := currentSource()
	// Hard coded line number, 34, in the "expectedSource" value
	expectedSource := "[namespace-lock_test.go:34:TestGetSource()]"
	if gotSource != expectedSource {
		t.Errorf("expected : %s, got : %s", expectedSource, gotSource)
	}
}

// Test lock race
func TestNSLockRace(t *testing.T) {
	t.Skip("long test skip it")

	ctx := t.Context()

	for i := range 10000 {
		nsLk := newNSLock(false)

        for (int i = 0; i < threadCount; i++) {
            assertNull(exceptions[i], "Thread " + i + " threw exception");
            assertNotNull(results[i], "Thread " + i + " got null result");
            Assertions.assertEquals(3, results[i].length, "Thread " + i + " got wrong array length");
        }
    }

    /**
     * Test that volatile fields ensure visibility across threads.

   *   method-reference linking tries to look up the system classloader, and it fails because there
   *   isn't one yet.
   *
   * - lambda: Outside Google, we got a report of a similar problem in
   *   https://github.com/google/guava/issues/6565
   */
  @SuppressWarnings("AnonymousToLambda")
  static final Supplier<StatsCounter> CACHE_STATS_COUNTER =

                thread.join();
            } catch (InterruptedException e) {
                fail("Thread interrupted: " + e.getMessage());
            }
        }

        // Verify all threads got the same instances
        for (int i = 0; i < threadCount; i++) {
            assertSame(invertibleCryptographer, invertibles[i]);
            assertSame(oneWayCryptographer, oneWays[i]);
        }
    }

          return null
        }
        val priorResponse = userResponse.priorResponse
        if (priorResponse != null && priorResponse.code == HTTP_CLIENT_TIMEOUT) {
          // We attempted to retry and got another timeout. Give up.
          return null
        }

        if (retryAfter(userResponse, 0) > 0) {
          return null
        }

        return userResponse.request
      }

      }
      assertEquivalent(expectedResult, collector.finisher().apply(finalAccum));
    }
  }

  private void assertEquivalent(R expected, R actual) {
    assertTrue(
        "Expected " + expected + " got " + actual + " modulo equivalence " + equivalence,
        equivalence.test(expected, actual));
  }

			var rule Rule
			err := xml.Unmarshal([]byte(tc.inputXML), &rule)
			if err != nil {
				t.Fatal(err)
			}

			if err := rule.Validate(); err != tc.expectedErr {
				t.Fatalf("%d: Expected %v but got %v", i+1, tc.expectedErr, err)
			}
		})
	}

        assertEquals(orig.getPassword(), copy.getPassword());

        // Test the cloning behavior with both null and non-null cached subjects
        if (first != null) {
            // If we got a valid subject, test that it's properly cached and cloned
            Subject cachedOrig = orig.getSubject();
            assertNotNull(cachedOrig);

            // Cached subject is copied and visible via getSubject()

      }
      assertEquivalent(expectedResult, collector.finisher().apply(finalAccum));
    }
  }

  private void assertEquivalent(R expected, R actual) {
    assertTrue(
        "Expected " + expected + " got " + actual + " modulo equivalence " + equivalence,
        equivalence.test(expected, actual));
  }

   */
  private void checkIsE(Object element) {
    checkNotNull(element);
    if (!isActuallyE(element)) {
      throw new ClassCastException("Expected an " + type + " but got " + element);
    }
  }

  @Override
  int distinctElements() {
    return distinctElements;
  }

  @Override
  public int size() {
    return Ints.saturatedCast(size);
  }