runtime/intern_table_test.cc - platform/art - Gitiles

 /*
  * Copyright (C) 2011 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 #include "intern_table.h"

 #include "base/hash_set.h"
 #include "common_runtime_test.h"
 #include "dex/utf.h"
 #include "gc_root-inl.h"
 #include "handle_scope-inl.h"
 #include "mirror/object.h"
 #include "mirror/string.h"
 #include "scoped_thread_state_change-inl.h"

 namespace art {

 class InternTableTest : public CommonRuntimeTest {};

 TEST_F(InternTableTest, Intern) {
   ScopedObjectAccess soa(Thread::Current());
   InternTable intern_table;
   StackHandleScope<4> hs(soa.Self());
   Handle<mirror::String> foo_1(hs.NewHandle(intern_table.InternStrong(3, "foo")));
   Handle<mirror::String> foo_2(hs.NewHandle(intern_table.InternStrong(3, "foo")));
   Handle<mirror::String> foo_3(
       hs.NewHandle(mirror::String::AllocFromModifiedUtf8(soa.Self(), "foo")));
   Handle<mirror::String> bar(hs.NewHandle(intern_table.InternStrong(3, "bar")));
   ASSERT_TRUE(foo_1 != nullptr);
   ASSERT_TRUE(foo_2 != nullptr);
   ASSERT_TRUE(foo_3 != nullptr);
   ASSERT_TRUE(bar != nullptr);
   EXPECT_EQ(foo_1.Get(), foo_2.Get());
   EXPECT_TRUE(foo_1->Equals("foo"));
   EXPECT_TRUE(foo_2->Equals("foo"));
   EXPECT_TRUE(foo_3->Equals("foo"));
   EXPECT_NE(foo_1.Get(), bar.Get());
   EXPECT_NE(foo_2.Get(), bar.Get());
   EXPECT_NE(foo_3.Get(), bar.Get());
 }

 TEST_F(InternTableTest, Size) {
   ScopedObjectAccess soa(Thread::Current());
   InternTable t;
   EXPECT_EQ(0U, t.Size());
   t.InternStrong(3, "foo");
   StackHandleScope<1> hs(soa.Self());
   Handle<mirror::String> foo(
       hs.NewHandle(mirror::String::AllocFromModifiedUtf8(soa.Self(), "foo")));
   t.InternWeak(foo.Get());
   EXPECT_EQ(1U, t.Size());
   t.InternStrong(3, "bar");
   EXPECT_EQ(2U, t.Size());
 }

 // Check if table indexes match on 64 and 32 bit machines.
 // This is done by ensuring hash values are the same on every machine and limited to 32-bit wide.
 // Otherwise cross compilation can cause a table to be filled on host using one indexing algorithm
 // and later on a device with different sizeof(size_t) can use another indexing algorithm.
 // Thus the table may provide wrong data.
 TEST_F(InternTableTest, CrossHash) {
   ScopedObjectAccess soa(Thread::Current());
   InternTable t;

   // A string that has a negative hash value.
   GcRoot<mirror::String> str(mirror::String::AllocFromModifiedUtf8(soa.Self(), "00000000"));

   MutexLock mu(Thread::Current(), *Locks::intern_table_lock_);
   for (InternTable::Table::UnorderedSet& table : t.strong_interns_.tables_) {
     // The negative hash value shall be 32-bit wide on every host.
     ASSERT_TRUE(IsUint<32>(table.hashfn_(str)));
   }
 }

 class TestPredicate : public IsMarkedVisitor {
  public:
   mirror::Object* IsMarked(mirror::Object* s) OVERRIDE REQUIRES_SHARED(Locks::mutator_lock_) {
     bool erased = false;
     for (auto it = expected_.begin(), end = expected_.end(); it != end; ++it) {
       if (*it == s) {
         expected_.erase(it);
         erased = true;
         break;
       }
     }
     EXPECT_TRUE(erased);
     return nullptr;
   }

   void Expect(const mirror::String* s) {
     expected_.push_back(s);
   }

   ~TestPredicate() {
     EXPECT_EQ(0U, expected_.size());
   }

  private:
   mutable std::vector<const mirror::String*> expected_;
 };

 TEST_F(InternTableTest, SweepInternTableWeaks) {
   ScopedObjectAccess soa(Thread::Current());
   InternTable t;
   t.InternStrong(3, "foo");
   t.InternStrong(3, "bar");
   StackHandleScope<5> hs(soa.Self());
   Handle<mirror::String> hello(
       hs.NewHandle(mirror::String::AllocFromModifiedUtf8(soa.Self(), "hello")));
   Handle<mirror::String> world(
       hs.NewHandle(mirror::String::AllocFromModifiedUtf8(soa.Self(), "world")));
   Handle<mirror::String> s0(hs.NewHandle(t.InternWeak(hello.Get())));
   Handle<mirror::String> s1(hs.NewHandle(t.InternWeak(world.Get())));

   EXPECT_EQ(4U, t.Size());

   // We should traverse only the weaks...
   TestPredicate p;
   p.Expect(s0.Get());
   p.Expect(s1.Get());
   {
     ReaderMutexLock mu(soa.Self(), *Locks::heap_bitmap_lock_);
     t.SweepInternTableWeaks(&p);
   }

   EXPECT_EQ(2U, t.Size());

   // Just check that we didn't corrupt the map.
   Handle<mirror::String> still_here(
       hs.NewHandle(mirror::String::AllocFromModifiedUtf8(soa.Self(), "still here")));
   t.InternWeak(still_here.Get());
   EXPECT_EQ(3U, t.Size());
 }

 TEST_F(InternTableTest, ContainsWeak) {
   ScopedObjectAccess soa(Thread::Current());
   {
     // Strongs are never weak.
     InternTable t;
     StackHandleScope<2> hs(soa.Self());
     Handle<mirror::String> interned_foo_1(hs.NewHandle(t.InternStrong(3, "foo")));
     EXPECT_FALSE(t.ContainsWeak(interned_foo_1.Get()));
     Handle<mirror::String> interned_foo_2(hs.NewHandle(t.InternStrong(3, "foo")));
     EXPECT_FALSE(t.ContainsWeak(interned_foo_2.Get()));
     EXPECT_EQ(interned_foo_1.Get(), interned_foo_2.Get());
   }

   {
     // Weaks are always weak.
     InternTable t;
     StackHandleScope<4> hs(soa.Self());
     Handle<mirror::String> foo_1(
         hs.NewHandle(mirror::String::AllocFromModifiedUtf8(soa.Self(), "foo")));
     Handle<mirror::String> foo_2(
         hs.NewHandle(mirror::String::AllocFromModifiedUtf8(soa.Self(), "foo")));
     EXPECT_NE(foo_1.Get(), foo_2.Get());
     Handle<mirror::String> interned_foo_1(hs.NewHandle(t.InternWeak(foo_1.Get())));
     Handle<mirror::String> interned_foo_2(hs.NewHandle(t.InternWeak(foo_2.Get())));
     EXPECT_TRUE(t.ContainsWeak(interned_foo_2.Get()));
     EXPECT_EQ(interned_foo_1.Get(), interned_foo_2.Get());
   }

   {
     // A weak can be promoted to a strong.
     InternTable t;
     StackHandleScope<3> hs(soa.Self());
     Handle<mirror::String> foo(
         hs.NewHandle(mirror::String::AllocFromModifiedUtf8(soa.Self(), "foo")));
     Handle<mirror::String> interned_foo_1(hs.NewHandle(t.InternWeak(foo.Get())));
     EXPECT_TRUE(t.ContainsWeak(interned_foo_1.Get()));
     Handle<mirror::String> interned_foo_2(hs.NewHandle(t.InternStrong(3, "foo")));
     EXPECT_FALSE(t.ContainsWeak(interned_foo_2.Get()));
     EXPECT_EQ(interned_foo_1.Get(), interned_foo_2.Get());
   }

   {
     // Interning a weak after a strong gets you the strong.
     InternTable t;
     StackHandleScope<3> hs(soa.Self());
     Handle<mirror::String> interned_foo_1(hs.NewHandle(t.InternStrong(3, "foo")));
     EXPECT_FALSE(t.ContainsWeak(interned_foo_1.Get()));
     Handle<mirror::String> foo(
         hs.NewHandle(mirror::String::AllocFromModifiedUtf8(soa.Self(), "foo")));
     Handle<mirror::String> interned_foo_2(hs.NewHandle(t.InternWeak(foo.Get())));
     EXPECT_FALSE(t.ContainsWeak(interned_foo_2.Get()));
     EXPECT_EQ(interned_foo_1.Get(), interned_foo_2.Get());
   }
 }

 TEST_F(InternTableTest, LookupStrong) {
   ScopedObjectAccess soa(Thread::Current());
   InternTable intern_table;
   StackHandleScope<3> hs(soa.Self());
   Handle<mirror::String> foo(hs.NewHandle(intern_table.InternStrong(3, "foo")));
   Handle<mirror::String> bar(hs.NewHandle(intern_table.InternStrong(3, "bar")));
   Handle<mirror::String> foobar(hs.NewHandle(intern_table.InternStrong(6, "foobar")));
   ASSERT_TRUE(foo != nullptr);
   ASSERT_TRUE(bar != nullptr);
   ASSERT_TRUE(foobar != nullptr);
   ASSERT_TRUE(foo->Equals("foo"));
   ASSERT_TRUE(bar->Equals("bar"));
   ASSERT_TRUE(foobar->Equals("foobar"));
   ASSERT_NE(foo.Get(), bar.Get());
   ASSERT_NE(foo.Get(), foobar.Get());
   ASSERT_NE(bar.Get(), foobar.Get());
   ObjPtr<mirror::String> lookup_foo = intern_table.LookupStrong(soa.Self(), 3, "foo");
   EXPECT_OBJ_PTR_EQ(lookup_foo, foo.Get());
   ObjPtr<mirror::String> lookup_bar = intern_table.LookupStrong(soa.Self(), 3, "bar");
   EXPECT_OBJ_PTR_EQ(lookup_bar, bar.Get());
   ObjPtr<mirror::String> lookup_foobar = intern_table.LookupStrong(soa.Self(), 6, "foobar");
   EXPECT_OBJ_PTR_EQ(lookup_foobar, foobar.Get());
   ObjPtr<mirror::String> lookup_foox = intern_table.LookupStrong(soa.Self(), 4, "foox");
   EXPECT_TRUE(lookup_foox == nullptr);
   ObjPtr<mirror::String> lookup_fooba = intern_table.LookupStrong(soa.Self(), 5, "fooba");
   EXPECT_TRUE(lookup_fooba == nullptr);
   ObjPtr<mirror::String> lookup_foobaR = intern_table.LookupStrong(soa.Self(), 6, "foobaR");
   EXPECT_TRUE(lookup_foobaR == nullptr);
   // Try a hash conflict.
   ASSERT_EQ(ComputeUtf16HashFromModifiedUtf8("foobar", 6),
             ComputeUtf16HashFromModifiedUtf8("foobbS", 6));
   ObjPtr<mirror::String> lookup_foobbS = intern_table.LookupStrong(soa.Self(), 6, "foobbS");
   EXPECT_TRUE(lookup_foobbS == nullptr);
 }

 }  // namespace art
	/*
	* Copyright (C) 2011 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	#include "intern_table.h"

	#include "base/hash_set.h"
	#include "common_runtime_test.h"
	#include "dex/utf.h"
	#include "gc_root-inl.h"
	#include "handle_scope-inl.h"
	#include "mirror/object.h"
	#include "mirror/string.h"
	#include "scoped_thread_state_change-inl.h"

	namespace art {

	class InternTableTest : public CommonRuntimeTest {};

	TEST_F(InternTableTest, Intern) {
	ScopedObjectAccess soa(Thread::Current());
	InternTable intern_table;
	StackHandleScope<4> hs(soa.Self());
	Handle<mirror::String> foo_1(hs.NewHandle(intern_table.InternStrong(3, "foo")));
	Handle<mirror::String> foo_2(hs.NewHandle(intern_table.InternStrong(3, "foo")));
	Handle<mirror::String> foo_3(
	hs.NewHandle(mirror::String::AllocFromModifiedUtf8(soa.Self(), "foo")));
	Handle<mirror::String> bar(hs.NewHandle(intern_table.InternStrong(3, "bar")));
	ASSERT_TRUE(foo_1 != nullptr);
	ASSERT_TRUE(foo_2 != nullptr);
	ASSERT_TRUE(foo_3 != nullptr);
	ASSERT_TRUE(bar != nullptr);
	EXPECT_EQ(foo_1.Get(), foo_2.Get());
	EXPECT_TRUE(foo_1->Equals("foo"));
	EXPECT_TRUE(foo_2->Equals("foo"));
	EXPECT_TRUE(foo_3->Equals("foo"));
	EXPECT_NE(foo_1.Get(), bar.Get());
	EXPECT_NE(foo_2.Get(), bar.Get());
	EXPECT_NE(foo_3.Get(), bar.Get());
	}

	TEST_F(InternTableTest, Size) {
	ScopedObjectAccess soa(Thread::Current());
	InternTable t;
	EXPECT_EQ(0U, t.Size());
	t.InternStrong(3, "foo");
	StackHandleScope<1> hs(soa.Self());
	Handle<mirror::String> foo(
	hs.NewHandle(mirror::String::AllocFromModifiedUtf8(soa.Self(), "foo")));
	t.InternWeak(foo.Get());
	EXPECT_EQ(1U, t.Size());
	t.InternStrong(3, "bar");
	EXPECT_EQ(2U, t.Size());
	}

	// Check if table indexes match on 64 and 32 bit machines.
	// This is done by ensuring hash values are the same on every machine and limited to 32-bit wide.
	// Otherwise cross compilation can cause a table to be filled on host using one indexing algorithm
	// and later on a device with different sizeof(size_t) can use another indexing algorithm.
	// Thus the table may provide wrong data.
	TEST_F(InternTableTest, CrossHash) {
	ScopedObjectAccess soa(Thread::Current());
	InternTable t;

	// A string that has a negative hash value.
	GcRoot<mirror::String> str(mirror::String::AllocFromModifiedUtf8(soa.Self(), "00000000"));

	MutexLock mu(Thread::Current(), *Locks::intern_table_lock_);
	for (InternTable::Table::UnorderedSet& table : t.strong_interns_.tables_) {
	// The negative hash value shall be 32-bit wide on every host.
	ASSERT_TRUE(IsUint<32>(table.hashfn_(str)));
	}
	}

	class TestPredicate : public IsMarkedVisitor {
	public:
	mirror::Object* IsMarked(mirror::Object* s) OVERRIDE REQUIRES_SHARED(Locks::mutator_lock_) {
	bool erased = false;
	for (auto it = expected_.begin(), end = expected_.end(); it != end; ++it) {
	if (*it == s) {
	expected_.erase(it);
	erased = true;
	break;
	}
	}
	EXPECT_TRUE(erased);
	return nullptr;
	}

	void Expect(const mirror::String* s) {
	expected_.push_back(s);
	}

	~TestPredicate() {
	EXPECT_EQ(0U, expected_.size());
	}

	private:
	mutable std::vector<const mirror::String*> expected_;
	};

	TEST_F(InternTableTest, SweepInternTableWeaks) {
	ScopedObjectAccess soa(Thread::Current());
	InternTable t;
	t.InternStrong(3, "foo");
	t.InternStrong(3, "bar");
	StackHandleScope<5> hs(soa.Self());
	Handle<mirror::String> hello(
	hs.NewHandle(mirror::String::AllocFromModifiedUtf8(soa.Self(), "hello")));
	Handle<mirror::String> world(
	hs.NewHandle(mirror::String::AllocFromModifiedUtf8(soa.Self(), "world")));
	Handle<mirror::String> s0(hs.NewHandle(t.InternWeak(hello.Get())));
	Handle<mirror::String> s1(hs.NewHandle(t.InternWeak(world.Get())));

	EXPECT_EQ(4U, t.Size());

	// We should traverse only the weaks...
	TestPredicate p;
	p.Expect(s0.Get());
	p.Expect(s1.Get());
	{
	ReaderMutexLock mu(soa.Self(), *Locks::heap_bitmap_lock_);
	t.SweepInternTableWeaks(&p);
	}

	EXPECT_EQ(2U, t.Size());

	// Just check that we didn't corrupt the map.
	Handle<mirror::String> still_here(
	hs.NewHandle(mirror::String::AllocFromModifiedUtf8(soa.Self(), "still here")));
	t.InternWeak(still_here.Get());
	EXPECT_EQ(3U, t.Size());
	}

	TEST_F(InternTableTest, ContainsWeak) {
	ScopedObjectAccess soa(Thread::Current());
	{
	// Strongs are never weak.
	InternTable t;
	StackHandleScope<2> hs(soa.Self());
	Handle<mirror::String> interned_foo_1(hs.NewHandle(t.InternStrong(3, "foo")));
	EXPECT_FALSE(t.ContainsWeak(interned_foo_1.Get()));
	Handle<mirror::String> interned_foo_2(hs.NewHandle(t.InternStrong(3, "foo")));
	EXPECT_FALSE(t.ContainsWeak(interned_foo_2.Get()));
	EXPECT_EQ(interned_foo_1.Get(), interned_foo_2.Get());
	}

	{
	// Weaks are always weak.
	InternTable t;
	StackHandleScope<4> hs(soa.Self());
	Handle<mirror::String> foo_1(
	hs.NewHandle(mirror::String::AllocFromModifiedUtf8(soa.Self(), "foo")));
	Handle<mirror::String> foo_2(
	hs.NewHandle(mirror::String::AllocFromModifiedUtf8(soa.Self(), "foo")));
	EXPECT_NE(foo_1.Get(), foo_2.Get());
	Handle<mirror::String> interned_foo_1(hs.NewHandle(t.InternWeak(foo_1.Get())));
	Handle<mirror::String> interned_foo_2(hs.NewHandle(t.InternWeak(foo_2.Get())));
	EXPECT_TRUE(t.ContainsWeak(interned_foo_2.Get()));
	EXPECT_EQ(interned_foo_1.Get(), interned_foo_2.Get());
	}

	{
	// A weak can be promoted to a strong.
	InternTable t;
	StackHandleScope<3> hs(soa.Self());
	Handle<mirror::String> foo(
	hs.NewHandle(mirror::String::AllocFromModifiedUtf8(soa.Self(), "foo")));
	Handle<mirror::String> interned_foo_1(hs.NewHandle(t.InternWeak(foo.Get())));
	EXPECT_TRUE(t.ContainsWeak(interned_foo_1.Get()));
	Handle<mirror::String> interned_foo_2(hs.NewHandle(t.InternStrong(3, "foo")));
	EXPECT_FALSE(t.ContainsWeak(interned_foo_2.Get()));
	EXPECT_EQ(interned_foo_1.Get(), interned_foo_2.Get());
	}

	{
	// Interning a weak after a strong gets you the strong.
	InternTable t;
	StackHandleScope<3> hs(soa.Self());
	Handle<mirror::String> interned_foo_1(hs.NewHandle(t.InternStrong(3, "foo")));
	EXPECT_FALSE(t.ContainsWeak(interned_foo_1.Get()));
	Handle<mirror::String> foo(
	hs.NewHandle(mirror::String::AllocFromModifiedUtf8(soa.Self(), "foo")));
	Handle<mirror::String> interned_foo_2(hs.NewHandle(t.InternWeak(foo.Get())));
	EXPECT_FALSE(t.ContainsWeak(interned_foo_2.Get()));
	EXPECT_EQ(interned_foo_1.Get(), interned_foo_2.Get());
	}
	}

	TEST_F(InternTableTest, LookupStrong) {
	ScopedObjectAccess soa(Thread::Current());
	InternTable intern_table;
	StackHandleScope<3> hs(soa.Self());
	Handle<mirror::String> foo(hs.NewHandle(intern_table.InternStrong(3, "foo")));
	Handle<mirror::String> bar(hs.NewHandle(intern_table.InternStrong(3, "bar")));
	Handle<mirror::String> foobar(hs.NewHandle(intern_table.InternStrong(6, "foobar")));
	ASSERT_TRUE(foo != nullptr);
	ASSERT_TRUE(bar != nullptr);
	ASSERT_TRUE(foobar != nullptr);
	ASSERT_TRUE(foo->Equals("foo"));
	ASSERT_TRUE(bar->Equals("bar"));
	ASSERT_TRUE(foobar->Equals("foobar"));
	ASSERT_NE(foo.Get(), bar.Get());
	ASSERT_NE(foo.Get(), foobar.Get());
	ASSERT_NE(bar.Get(), foobar.Get());
	ObjPtr<mirror::String> lookup_foo = intern_table.LookupStrong(soa.Self(), 3, "foo");
	EXPECT_OBJ_PTR_EQ(lookup_foo, foo.Get());
	ObjPtr<mirror::String> lookup_bar = intern_table.LookupStrong(soa.Self(), 3, "bar");
	EXPECT_OBJ_PTR_EQ(lookup_bar, bar.Get());
	ObjPtr<mirror::String> lookup_foobar = intern_table.LookupStrong(soa.Self(), 6, "foobar");
	EXPECT_OBJ_PTR_EQ(lookup_foobar, foobar.Get());
	ObjPtr<mirror::String> lookup_foox = intern_table.LookupStrong(soa.Self(), 4, "foox");
	EXPECT_TRUE(lookup_foox == nullptr);
	ObjPtr<mirror::String> lookup_fooba = intern_table.LookupStrong(soa.Self(), 5, "fooba");
	EXPECT_TRUE(lookup_fooba == nullptr);
	ObjPtr<mirror::String> lookup_foobaR = intern_table.LookupStrong(soa.Self(), 6, "foobaR");
	EXPECT_TRUE(lookup_foobaR == nullptr);
	// Try a hash conflict.
	ASSERT_EQ(ComputeUtf16HashFromModifiedUtf8("foobar", 6),
	ComputeUtf16HashFromModifiedUtf8("foobbS", 6));
	ObjPtr<mirror::String> lookup_foobbS = intern_table.LookupStrong(soa.Self(), 6, "foobbS");
	EXPECT_TRUE(lookup_foobbS == nullptr);
	}

	} // namespace art