diff options
Diffstat (limited to 'runtime/lambda_proxy_test.cc')
| -rw-r--r-- | runtime/lambda_proxy_test.cc | 367 |
1 files changed, 0 insertions, 367 deletions
diff --git a/runtime/lambda_proxy_test.cc b/runtime/lambda_proxy_test.cc deleted file mode 100644 index 63d6cccedb..0000000000 --- a/runtime/lambda_proxy_test.cc +++ /dev/null @@ -1,367 +0,0 @@ -/* - * Copyright (C) 2015 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 <jni.h> -#include <vector> - -#include "art_field-inl.h" -#include "class_linker-inl.h" -#include "compiler_callbacks.h" -#include "common_compiler_test.h" -#include "mirror/field-inl.h" -#include "mirror/lambda_proxy.h" -#include "mirror/method.h" -#include "scoped_thread_state_change.h" - -namespace art { - -// The enclosing class of all the interfaces used by this test. -// -- Defined as a macro to allow for string concatenation. -#define TEST_INTERFACE_ENCLOSING_CLASS_NAME "LambdaInterfaces" -// Generate out "LLambdaInterfaces$<<iface>>;" , replacing <<iface>> with the interface name. -#define MAKE_TEST_INTERFACE_NAME(iface) ("L" TEST_INTERFACE_ENCLOSING_CLASS_NAME "$" iface ";") - -#define ASSERT_NOT_NULL(x) ASSERT_TRUE((x) != nullptr) -#define ASSERT_NULL(x) ASSERT_TRUE((x) == nullptr) -#define EXPECT_NULL(x) EXPECT_TRUE((x) == nullptr) - -class LambdaProxyTest // : public CommonCompilerTest { - : public CommonRuntimeTest { - public: - // Generate a lambda proxy class with the given name and interfaces. This is a simplification from what - // libcore does to fit to our test needs. We do not check for duplicated interfaces or methods and - // we do not declare exceptions. - mirror::Class* GenerateProxyClass(ScopedObjectAccess& soa, - jobject jclass_loader, - const char* class_name, - const std::vector<mirror::Class*>& interfaces) - SHARED_REQUIRES(Locks::mutator_lock_) { - CHECK(class_name != nullptr); - CHECK(jclass_loader != nullptr); - - mirror::Class* java_lang_object = - class_linker_->FindSystemClass(soa.Self(), "Ljava/lang/Object;"); - CHECK(java_lang_object != nullptr); - - jclass java_lang_class = soa.AddLocalReference<jclass>(mirror::Class::GetJavaLangClass()); - - // Builds the interfaces array. - jobjectArray proxy_class_interfaces = soa.Env()->NewObjectArray(interfaces.size(), - java_lang_class, - nullptr); // No initial element. - soa.Self()->AssertNoPendingException(); - for (size_t i = 0; i < interfaces.size(); ++i) { - soa.Env()->SetObjectArrayElement(proxy_class_interfaces, - i, - soa.AddLocalReference<jclass>(interfaces[i])); - } - - // Builds the method array. - jsize methods_count = 3; // Object.equals, Object.hashCode and Object.toString. - for (mirror::Class* interface : interfaces) { - methods_count += interface->NumVirtualMethods(); - } - jobjectArray proxy_class_methods = - soa.Env()->NewObjectArray(methods_count, - soa.AddLocalReference<jclass>(mirror::Method::StaticClass()), - nullptr); // No initial element. - soa.Self()->AssertNoPendingException(); - - jsize array_index = 0; - - // - // Fill the method array with the Object and all the interface's virtual methods. - // - - // Add a method to 'proxy_class_methods' - auto add_method_to_array = [&](ArtMethod* method) SHARED_REQUIRES(Locks::mutator_lock_) { - CHECK(method != nullptr); - soa.Env()->SetObjectArrayElement(proxy_class_methods, - array_index++, - soa.AddLocalReference<jobject>( - mirror::Method::CreateFromArtMethod(soa.Self(), - method)) - ); // NOLINT: [whitespace/parens] [2] - - LOG(DEBUG) << "Add " << PrettyMethod(method) << " to list of methods to generate proxy"; - }; - // Add a method to 'proxy_class_methods' by looking it up from java.lang.Object - auto add_method_to_array_by_lookup = [&](const char* name, const char* method_descriptor) - SHARED_REQUIRES(Locks::mutator_lock_) { - ArtMethod* method = java_lang_object->FindDeclaredVirtualMethod(name, - method_descriptor, - sizeof(void*)); - add_method_to_array(method); - }; - - // Add all methods from Object. - add_method_to_array_by_lookup("equals", "(Ljava/lang/Object;)Z"); - add_method_to_array_by_lookup("hashCode", "()I"); - add_method_to_array_by_lookup("toString", "()Ljava/lang/String;"); - - // Now adds all interfaces virtual methods. - for (mirror::Class* interface : interfaces) { - mirror::Class* next_class = interface; - do { - for (ArtMethod& method : next_class->GetVirtualMethods(sizeof(void*))) { - add_method_to_array(&method); - } - next_class = next_class->GetSuperClass(); - } while (!next_class->IsObjectClass()); - // Skip adding any methods from "Object". - } - CHECK_EQ(array_index, methods_count); - - // Builds an empty exception array. - jobjectArray proxy_class_throws = soa.Env()->NewObjectArray(0 /* length */, - java_lang_class, - nullptr /* initial element*/); - soa.Self()->AssertNoPendingException(); - - bool already_exists; - mirror::Class* proxy_class = - class_linker_->CreateLambdaProxyClass(soa, - soa.Env()->NewStringUTF(class_name), - proxy_class_interfaces, - jclass_loader, - proxy_class_methods, - proxy_class_throws, - /*out*/&already_exists); - - CHECK(!already_exists); - - soa.Self()->AssertNoPendingException(); - return proxy_class; - } - - LambdaProxyTest() { - } - - virtual void SetUp() { - CommonRuntimeTest::SetUp(); - } - - virtual void SetUpRuntimeOptions(RuntimeOptions* options ATTRIBUTE_UNUSED) { - // Do not have any compiler options because we don't want to run as an AOT - // (In particular the lambda proxy class generation isn't currently supported for AOT). - this->callbacks_.reset(); - } - - template <typename THandleScope> - Handle<mirror::Class> GenerateProxyClass(THandleScope& hs, - const char* name, - const std::vector<mirror::Class*>& interfaces) - SHARED_REQUIRES(Locks::mutator_lock_) { - return hs.NewHandle(GenerateProxyClass(*soa_, jclass_loader_, name, interfaces)); - } - - protected: - ScopedObjectAccess* soa_ = nullptr; - jobject jclass_loader_ = nullptr; -}; - -// Creates a lambda proxy class and check ClassHelper works correctly. -TEST_F(LambdaProxyTest, ProxyClassHelper) { - // gLogVerbosity.class_linker = true; // Uncomment to enable class linker logging. - - ASSERT_NOT_NULL(Thread::Current()); - - ScopedObjectAccess soa(Thread::Current()); - soa_ = &soa; - - // Must happen after CommonRuntimeTest finishes constructing the runtime. - jclass_loader_ = LoadDex(TEST_INTERFACE_ENCLOSING_CLASS_NAME); - jobject jclass_loader = jclass_loader_; - - StackHandleScope<4> hs(soa.Self()); - Handle<mirror::ClassLoader> class_loader( - hs.NewHandle(soa.Decode<mirror::ClassLoader*>(jclass_loader))); - - Handle<mirror::Class> J(hs.NewHandle( - class_linker_->FindClass(soa.Self(), MAKE_TEST_INTERFACE_NAME("J"), class_loader))); - ASSERT_TRUE(J.Get() != nullptr); - - std::vector<mirror::Class*> interfaces; - interfaces.push_back(J.Get()); - Handle<mirror::Class> proxy_class(hs.NewHandle( - GenerateProxyClass(soa, jclass_loader, "$Proxy1234", interfaces))); - interfaces.clear(); // Don't least possibly stale objects in the array as good practice. - ASSERT_TRUE(proxy_class.Get() != nullptr); - ASSERT_TRUE(proxy_class->IsLambdaProxyClass()); - ASSERT_TRUE(proxy_class->IsInitialized()); - - EXPECT_EQ(1U, proxy_class->NumDirectInterfaces()); // LambdaInterfaces$J. - EXPECT_EQ(J.Get(), mirror::Class::GetDirectInterface(soa.Self(), proxy_class, 0)); - std::string temp; - const char* proxy_class_descriptor = proxy_class->GetDescriptor(&temp); - EXPECT_STREQ("L$Proxy1234;", proxy_class_descriptor); - EXPECT_EQ(nullptr, proxy_class->GetSourceFile()); - - // Make sure all the virtual methods are marked as a proxy - for (ArtMethod& method : proxy_class->GetVirtualMethods(sizeof(void*))) { - SCOPED_TRACE(PrettyMethod(&method, /* with_signature */true)); - EXPECT_TRUE(method.IsProxyMethod()); - EXPECT_TRUE(method.IsLambdaProxyMethod()); - EXPECT_FALSE(method.IsReflectProxyMethod()); - } -} - -// Creates a proxy class and check FieldHelper works correctly. -TEST_F(LambdaProxyTest, ProxyFieldHelper) { - // gLogVerbosity.class_linker = true; // Uncomment to enable class linker logging. - - ASSERT_NOT_NULL(Thread::Current()); - - ScopedObjectAccess soa(Thread::Current()); - soa_ = &soa; - - // Must happen after CommonRuntimeTest finishes constructing the runtime. - jclass_loader_ = LoadDex(TEST_INTERFACE_ENCLOSING_CLASS_NAME); - jobject jclass_loader = jclass_loader_; - - StackHandleScope<9> hs(soa.Self()); - Handle<mirror::ClassLoader> class_loader( - hs.NewHandle(soa.Decode<mirror::ClassLoader*>(jclass_loader))); - - Handle<mirror::Class> I(hs.NewHandle( - class_linker_->FindClass(soa.Self(), MAKE_TEST_INTERFACE_NAME("I"), class_loader))); - ASSERT_NOT_NULL(I.Get()); - - // Create the lambda proxy which implements interfaces "I". - Handle<mirror::Class> proxy_class = GenerateProxyClass(hs, - "$Proxy1234", - { I.Get() }); // Interfaces. - - ASSERT_NOT_NULL(proxy_class.Get()); - EXPECT_TRUE(proxy_class->IsLambdaProxyClass()); - EXPECT_TRUE(proxy_class->IsInitialized()); - EXPECT_NULL(proxy_class->GetIFieldsPtr()); - - LengthPrefixedArray<ArtField>* static_fields = proxy_class->GetSFieldsPtr(); - ASSERT_NOT_NULL(static_fields); - - // Must have "throws" and "interfaces" static fields. - ASSERT_EQ(+mirror::LambdaProxy::kStaticFieldCount, proxy_class->NumStaticFields()); - - static constexpr const char* kInterfacesClassName = "[Ljava/lang/Class;"; - static constexpr const char* kThrowsClassName = "[[Ljava/lang/Class;"; - - // Class for "interfaces" field. - Handle<mirror::Class> interfaces_field_class = - hs.NewHandle(class_linker_->FindSystemClass(soa.Self(), kInterfacesClassName)); - ASSERT_NOT_NULL(interfaces_field_class.Get()); - - // Class for "throws" field. - Handle<mirror::Class> throws_field_class = - hs.NewHandle(class_linker_->FindSystemClass(soa.Self(), kThrowsClassName)); - ASSERT_NOT_NULL(throws_field_class.Get()); - - // Helper to test the static fields for correctness. - auto test_static_field = [&](size_t index, - const char* field_name, - Handle<mirror::Class>& handle_class, - const char* class_name) - SHARED_REQUIRES(Locks::mutator_lock_) { - ArtField* field = &static_fields->At(index); - EXPECT_STREQ(field_name, field->GetName()); - EXPECT_STREQ(class_name, field->GetTypeDescriptor()); - EXPECT_EQ(handle_class.Get(), field->GetType</*kResolve*/true>()) - << "Expected: " << PrettyClass(interfaces_field_class.Get()) << ", " - << "Actual: " << PrettyClass(field->GetType</*kResolve*/true>()) << ", " - << "field_name: " << field_name; - std::string temp; - EXPECT_STREQ("L$Proxy1234;", field->GetDeclaringClass()->GetDescriptor(&temp)); - EXPECT_FALSE(field->IsPrimitiveType()); - }; - - // Test "Class[] interfaces" field. - test_static_field(mirror::LambdaProxy::kStaticFieldIndexInterfaces, - "interfaces", - interfaces_field_class, - kInterfacesClassName); - - // Test "Class[][] throws" field. - test_static_field(mirror::LambdaProxy::kStaticFieldIndexThrows, - "throws", - throws_field_class, - kThrowsClassName); -} - -// Creates two proxy classes and check the art/mirror fields of their static fields. -TEST_F(LambdaProxyTest, CheckArtMirrorFieldsOfProxyStaticFields) { - // gLogVerbosity.class_linker = true; // Uncomment to enable class linker logging. - - ASSERT_NOT_NULL(Thread::Current()); - - ScopedObjectAccess soa(Thread::Current()); - soa_ = &soa; - - // Must happen after CommonRuntimeTest finishes constructing the runtime. - jclass_loader_ = LoadDex(TEST_INTERFACE_ENCLOSING_CLASS_NAME); - jobject jclass_loader = jclass_loader_; - - StackHandleScope<8> hs(soa.Self()); - Handle<mirror::ClassLoader> class_loader( - hs.NewHandle(soa.Decode<mirror::ClassLoader*>(jclass_loader))); - - Handle<mirror::Class> proxyClass0; - Handle<mirror::Class> proxyClass1; - { - Handle<mirror::Class> L(hs.NewHandle( - class_linker_->FindClass(soa.Self(), MAKE_TEST_INTERFACE_NAME("L"), class_loader))); - ASSERT_TRUE(L.Get() != nullptr); - - std::vector<mirror::Class*> interfaces = { L.Get() }; - proxyClass0 = hs.NewHandle(GenerateProxyClass(soa, jclass_loader, "$Proxy0", interfaces)); - proxyClass1 = hs.NewHandle(GenerateProxyClass(soa, jclass_loader, "$Proxy1", interfaces)); - } - - ASSERT_TRUE(proxyClass0.Get() != nullptr); - ASSERT_TRUE(proxyClass0->IsLambdaProxyClass()); - ASSERT_TRUE(proxyClass0->IsInitialized()); - ASSERT_TRUE(proxyClass1.Get() != nullptr); - ASSERT_TRUE(proxyClass1->IsLambdaProxyClass()); - ASSERT_TRUE(proxyClass1->IsInitialized()); - - LengthPrefixedArray<ArtField>* static_fields0 = proxyClass0->GetSFieldsPtr(); - ASSERT_TRUE(static_fields0 != nullptr); - ASSERT_EQ(2u, static_fields0->size()); - LengthPrefixedArray<ArtField>* static_fields1 = proxyClass1->GetSFieldsPtr(); - ASSERT_TRUE(static_fields1 != nullptr); - ASSERT_EQ(2u, static_fields1->size()); - - EXPECT_EQ(static_fields0->At(0).GetDeclaringClass(), proxyClass0.Get()); - EXPECT_EQ(static_fields0->At(1).GetDeclaringClass(), proxyClass0.Get()); - EXPECT_EQ(static_fields1->At(0).GetDeclaringClass(), proxyClass1.Get()); - EXPECT_EQ(static_fields1->At(1).GetDeclaringClass(), proxyClass1.Get()); - - Handle<mirror::Field> field00 = - hs.NewHandle(mirror::Field::CreateFromArtField(soa.Self(), &static_fields0->At(0), true)); - Handle<mirror::Field> field01 = - hs.NewHandle(mirror::Field::CreateFromArtField(soa.Self(), &static_fields0->At(1), true)); - Handle<mirror::Field> field10 = - hs.NewHandle(mirror::Field::CreateFromArtField(soa.Self(), &static_fields1->At(0), true)); - Handle<mirror::Field> field11 = - hs.NewHandle(mirror::Field::CreateFromArtField(soa.Self(), &static_fields1->At(1), true)); - EXPECT_EQ(field00->GetArtField(), &static_fields0->At(0)); - EXPECT_EQ(field01->GetArtField(), &static_fields0->At(1)); - EXPECT_EQ(field10->GetArtField(), &static_fields1->At(0)); - EXPECT_EQ(field11->GetArtField(), &static_fields1->At(1)); -} - -// TODO: make sure there's a non-abstract implementation of the single-abstract-method on the class. - -} // namespace art |