ppapi/tests/test_case.cc - chromium/src - Git at Google

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 #include "ppapi/tests/test_case.h"

 #include <stddef.h>
 #include <string.h>

 #include <algorithm>
 #include <sstream>

 #include "ppapi/cpp/core.h"
 #include "ppapi/cpp/module.h"
 #include "ppapi/tests/pp_thread.h"
 #include "ppapi/tests/test_utils.h"
 #include "ppapi/tests/testing_instance.h"

 namespace {

 std::string StripPrefix(const std::string& test_name) {
   if (test_name.find("DISABLED_") == 0)
     return test_name.substr(strlen("DISABLED_"));
   return test_name;
 }

 // Strip the TestCase name off and return the remainder (i.e., everything after
 // '_'). If there is no '_', assume only the TestCase was provided, and return
 // an empty string.
 // For example:
 //   StripTestCase("TestCase_TestName");
 // returns
 //   "TestName"
 // while
 //   StripTestCase("TestCase);
 // returns
 //   ""
 std::string StripTestCase(const std::string& full_test_name) {
   size_t delim = full_test_name.find_first_of('_');
   if (delim != std::string::npos)
     return full_test_name.substr(delim+1);
   // In this case, our "filter" is the empty string; the full test name is the
   // same as the TestCase name with which we were constructed.
   // TODO(dmichael): It might be nice to be able to PP_DCHECK against the
   // TestCase class name, but we'd have to plumb that name to TestCase somehow.
   return std::string();
 }

 // Parse |test_filter|, which is a comma-delimited list of (possibly prefixed)
 // test names and insert the un-prefixed names into |remaining_tests|, with
 // the bool indicating whether the test should be run.
 void ParseTestFilter(const std::string& test_filter,
                      std::map<std::string, bool>* remaining_tests) {
   // We can't use base/strings/string_util.h::Tokenize in ppapi, so we have to
   // do it ourselves.
   std::istringstream filter_stream(test_filter);
   std::string current_test;
   while (std::getline(filter_stream, current_test, ',')) {
     // |current_test| might include a prefix, like DISABLED_Foo_TestBar, so we
     // we strip it off if there is one.
     std::string stripped_test_name(StripPrefix(current_test));
     // Strip off the test case and use the test name as a key, because the test
     // name ShouldRunTest wants to use to look up the test doesn't have the
     // TestCase name.
     std::string test_name_without_case(StripTestCase(stripped_test_name));

     // If the test wasn't prefixed, it should be run.
     bool should_run_test = (current_test == stripped_test_name);
     PP_DCHECK(remaining_tests->count(test_name_without_case) == 0);
     remaining_tests->insert(
         std::make_pair(test_name_without_case, should_run_test));
   }
   // There may be a trailing comma; ignore empty strings.
   remaining_tests->erase(std::string());
 }

 }  // namespace

 TestCase::TestCase(TestingInstance* instance)
     : instance_(instance),
       testing_interface_(NULL),
       callback_type_(PP_REQUIRED),
       have_populated_filter_tests_(false) {
   // Get the testing_interface_ if it is available, so that we can do Resource
   // and Var checks on shutdown (see CheckResourcesAndVars). If it is not
   // available, testing_interface_ will be NULL. Some tests do not require it.
   testing_interface_ = GetTestingInterface();
 }

 TestCase::~TestCase() {
 }

 bool TestCase::Init() {
   return true;
 }

 // static
 std::string TestCase::MakeFailureMessage(const char* file,
                                          int line,
                                          const char* cmd) {
   std::ostringstream output;
   output << "Failure in " << file << "(" << line << "): " << cmd;
   return output.str();
 }

 #if !(defined __native_client__)
 pp::VarPrivate TestCase::GetTestObject() {
   if (test_object_.is_undefined()) {
     pp::deprecated::ScriptableObject* so = CreateTestObject();
     if (so) {
       test_object_ = pp::VarPrivate(instance_, so);  // Takes ownership.
       // CheckResourcesAndVars runs and looks for leaks before we've actually
       // completely shut down. Ignore the instance object, since it's not a real
       // leak.
       IgnoreLeakedVar(test_object_.pp_var().value.as_id);
     }
   }
   return test_object_;
 }
 #endif

 bool TestCase::CheckTestingInterface() {
   testing_interface_ = GetTestingInterface();
   if (!testing_interface_) {
     // Give a more helpful error message for the testing interface being gone
     // since that needs special enabling in Chrome.
     instance_->AppendError("This test needs the testing interface, which is "
                            "not currently available. In Chrome, use "
                            "--enable-pepper-testing when launching.");
     return false;
   }

   return true;
 }

 void TestCase::HandleMessage(const pp::Var& message_data) {
 }

 void TestCase::DidChangeView(const pp::View& view) {
 }

 bool TestCase::HandleInputEvent(const pp::InputEvent& event) {
   return false;
 }

 void TestCase::IgnoreLeakedVar(int64_t id) {
   ignored_leaked_vars_.insert(id);
 }

 #if !(defined __native_client__)
 pp::deprecated::ScriptableObject* TestCase::CreateTestObject() {
   return NULL;
 }
 #endif

 bool TestCase::EnsureRunningOverHTTP() {
   if (instance_->protocol() != "http:") {
     instance_->AppendError("This test needs to be run over HTTP.");
     return false;
   }

   return true;
 }

 bool TestCase::ShouldRunAllTests(const std::string& filter) {
   // If only the TestCase is listed, we're running all the tests in RunTests.
   return (StripTestCase(filter) == std::string());
 }

 bool TestCase::ShouldRunTest(const std::string& test_name,
                              const std::string& filter) {
   if (ShouldRunAllTests(filter))
     return true;

   // Lazily initialize our "filter_tests_" map.
   if (!have_populated_filter_tests_) {
     ParseTestFilter(filter, &filter_tests_);
     remaining_tests_ = filter_tests_;
     have_populated_filter_tests_ = true;
   }
   std::map<std::string, bool>::iterator iter = filter_tests_.find(test_name);
   if (iter == filter_tests_.end()) {
     // The test name wasn't listed in the filter. Don't run it, but store it
     // so TestingInstance::ExecuteTests can report an error later.
     skipped_tests_.insert(test_name);
     return false;
   }
   remaining_tests_.erase(test_name);
   return iter->second;
 }

 PP_TimeTicks TestCase::NowInTimeTicks() {
   return pp::Module::Get()->core()->GetTimeTicks();
 }

 std::string TestCase::CheckResourcesAndVars(std::string errors) {
   if (!errors.empty())
     return errors;

   if (testing_interface_) {
     // TODO(dmichael): Fix tests that leak resources and enable the following:
     /*
     uint32_t leaked_resources =
         testing_interface_->GetLiveObjectsForInstance(instance_->pp_instance());
     if (leaked_resources) {
       std::ostringstream output;
       output << "FAILED: Test leaked " << leaked_resources << " resources.\n";
       errors += output.str();
     }
     */
     const int kVarsToPrint = 100;
     PP_Var vars[kVarsToPrint];
     int found_vars = testing_interface_->GetLiveVars(vars, kVarsToPrint);
     // This will undercount if we are told to ignore a Var which is then *not*
     // leaked. Worst case, we just won't print the little "Test leaked" message,
     // but we'll still print any non-ignored leaked vars we found.
     int leaked_vars =
         found_vars - static_cast<int>(ignored_leaked_vars_.size());
     if (leaked_vars > 0) {
       std::ostringstream output;
       output << "Test leaked " << leaked_vars << " vars (printing at most "
              << kVarsToPrint <<"):<p>";
       errors += output.str();
     }
     for (int i = 0; i < std::min(found_vars, kVarsToPrint); ++i) {
       pp::Var leaked_var(pp::PASS_REF, vars[i]);
       if (ignored_leaked_vars_.count(leaked_var.pp_var().value.as_id) == 0)
         errors += leaked_var.DebugString() + "<p>";
     }
   }
   return errors;
 }

 // static
 void TestCase::QuitMainMessageLoop(PP_Instance instance) {
   PP_Instance* heap_instance = new PP_Instance(instance);
   pp::CompletionCallback callback(&DoQuitMainMessageLoop, heap_instance);
   pp::Module::Get()->core()->CallOnMainThread(0, callback);
 }

 // static
 void TestCase::DoQuitMainMessageLoop(void* pp_instance, int32_t result) {
   PP_Instance* instance = static_cast<PP_Instance*>(pp_instance);
   GetTestingInterface()->QuitMessageLoop(*instance);
   delete instance;
 }

 void TestCase::RunOnThreadInternal(
     void (*thread_func)(void*),
     void* thread_param,
     const PPB_Testing_Private* testing_interface) {
   PP_Thread thread;
   PP_CreateThread(&thread, thread_func, thread_param);
   // Run a message loop so pepper calls can be dispatched. The background
   // thread will set result_ and make us Quit when it's done.
   testing_interface->RunMessageLoop(instance_->pp_instance());
   PP_JoinThread(thread);
 }
	// Copyright (c) 2012 The Chromium Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	#include "ppapi/tests/test_case.h"

	#include <stddef.h>
	#include <string.h>

	#include <algorithm>
	#include <sstream>

	#include "ppapi/cpp/core.h"
	#include "ppapi/cpp/module.h"
	#include "ppapi/tests/pp_thread.h"
	#include "ppapi/tests/test_utils.h"
	#include "ppapi/tests/testing_instance.h"

	namespace {

	std::string StripPrefix(const std::string& test_name) {
	if (test_name.find("DISABLED_") == 0)
	return test_name.substr(strlen("DISABLED_"));
	return test_name;
	}

	// Strip the TestCase name off and return the remainder (i.e., everything after
	// '_'). If there is no '_', assume only the TestCase was provided, and return
	// an empty string.
	// For example:
	// StripTestCase("TestCase_TestName");
	// returns
	// "TestName"
	// while
	// StripTestCase("TestCase);
	// returns
	// ""
	std::string StripTestCase(const std::string& full_test_name) {
	size_t delim = full_test_name.find_first_of('_');
	if (delim != std::string::npos)
	return full_test_name.substr(delim+1);
	// In this case, our "filter" is the empty string; the full test name is the
	// same as the TestCase name with which we were constructed.
	// TODO(dmichael): It might be nice to be able to PP_DCHECK against the
	// TestCase class name, but we'd have to plumb that name to TestCase somehow.
	return std::string();
	}

	// Parse \|test_filter\|, which is a comma-delimited list of (possibly prefixed)
	// test names and insert the un-prefixed names into \|remaining_tests\|, with
	// the bool indicating whether the test should be run.
	void ParseTestFilter(const std::string& test_filter,
	std::map<std::string, bool>* remaining_tests) {
	// We can't use base/strings/string_util.h::Tokenize in ppapi, so we have to
	// do it ourselves.
	std::istringstream filter_stream(test_filter);
	std::string current_test;
	while (std::getline(filter_stream, current_test, ',')) {
	// \|current_test\| might include a prefix, like DISABLED_Foo_TestBar, so we
	// we strip it off if there is one.
	std::string stripped_test_name(StripPrefix(current_test));
	// Strip off the test case and use the test name as a key, because the test
	// name ShouldRunTest wants to use to look up the test doesn't have the
	// TestCase name.
	std::string test_name_without_case(StripTestCase(stripped_test_name));

	// If the test wasn't prefixed, it should be run.
	bool should_run_test = (current_test == stripped_test_name);
	PP_DCHECK(remaining_tests->count(test_name_without_case) == 0);
	remaining_tests->insert(
	std::make_pair(test_name_without_case, should_run_test));
	}
	// There may be a trailing comma; ignore empty strings.
	remaining_tests->erase(std::string());
	}

	} // namespace

	TestCase::TestCase(TestingInstance* instance)
	: instance_(instance),
	testing_interface_(NULL),
	callback_type_(PP_REQUIRED),
	have_populated_filter_tests_(false) {
	// Get the testing_interface_ if it is available, so that we can do Resource
	// and Var checks on shutdown (see CheckResourcesAndVars). If it is not
	// available, testing_interface_ will be NULL. Some tests do not require it.
	testing_interface_ = GetTestingInterface();
	}

	TestCase::~TestCase() {
	}

	bool TestCase::Init() {
	return true;
	}

	// static
	std::string TestCase::MakeFailureMessage(const char* file,
	int line,
	const char* cmd) {
	std::ostringstream output;
	output << "Failure in " << file << "(" << line << "): " << cmd;
	return output.str();
	}

	#if !(defined __native_client__)
	pp::VarPrivate TestCase::GetTestObject() {
	if (test_object_.is_undefined()) {
	pp::deprecated::ScriptableObject* so = CreateTestObject();
	if (so) {
	test_object_ = pp::VarPrivate(instance_, so); // Takes ownership.
	// CheckResourcesAndVars runs and looks for leaks before we've actually
	// completely shut down. Ignore the instance object, since it's not a real
	// leak.
	IgnoreLeakedVar(test_object_.pp_var().value.as_id);
	}
	}
	return test_object_;
	}
	#endif

	bool TestCase::CheckTestingInterface() {
	testing_interface_ = GetTestingInterface();
	if (!testing_interface_) {
	// Give a more helpful error message for the testing interface being gone
	// since that needs special enabling in Chrome.
	instance_->AppendError("This test needs the testing interface, which is "
	"not currently available. In Chrome, use "
	"--enable-pepper-testing when launching.");
	return false;
	}

	return true;
	}

	void TestCase::HandleMessage(const pp::Var& message_data) {
	}

	void TestCase::DidChangeView(const pp::View& view) {
	}

	bool TestCase::HandleInputEvent(const pp::InputEvent& event) {
	return false;
	}

	void TestCase::IgnoreLeakedVar(int64_t id) {
	ignored_leaked_vars_.insert(id);
	}

	#if !(defined __native_client__)
	pp::deprecated::ScriptableObject* TestCase::CreateTestObject() {
	return NULL;
	}
	#endif

	bool TestCase::EnsureRunningOverHTTP() {
	if (instance_->protocol() != "http:") {
	instance_->AppendError("This test needs to be run over HTTP.");
	return false;
	}

	return true;
	}

	bool TestCase::ShouldRunAllTests(const std::string& filter) {
	// If only the TestCase is listed, we're running all the tests in RunTests.
	return (StripTestCase(filter) == std::string());
	}

	bool TestCase::ShouldRunTest(const std::string& test_name,
	const std::string& filter) {
	if (ShouldRunAllTests(filter))
	return true;

	// Lazily initialize our "filter_tests_" map.
	if (!have_populated_filter_tests_) {
	ParseTestFilter(filter, &filter_tests_);
	remaining_tests_ = filter_tests_;
	have_populated_filter_tests_ = true;
	}
	std::map<std::string, bool>::iterator iter = filter_tests_.find(test_name);
	if (iter == filter_tests_.end()) {
	// The test name wasn't listed in the filter. Don't run it, but store it
	// so TestingInstance::ExecuteTests can report an error later.
	skipped_tests_.insert(test_name);
	return false;
	}
	remaining_tests_.erase(test_name);
	return iter->second;
	}

	PP_TimeTicks TestCase::NowInTimeTicks() {
	return pp::Module::Get()->core()->GetTimeTicks();
	}

	std::string TestCase::CheckResourcesAndVars(std::string errors) {
	if (!errors.empty())
	return errors;

	if (testing_interface_) {
	// TODO(dmichael): Fix tests that leak resources and enable the following:
	/*
	uint32_t leaked_resources =
	testing_interface_->GetLiveObjectsForInstance(instance_->pp_instance());
	if (leaked_resources) {
	std::ostringstream output;
	output << "FAILED: Test leaked " << leaked_resources << " resources.\n";
	errors += output.str();
	}
	*/
	const int kVarsToPrint = 100;
	PP_Var vars[kVarsToPrint];
	int found_vars = testing_interface_->GetLiveVars(vars, kVarsToPrint);
	// This will undercount if we are told to ignore a Var which is then not
	// leaked. Worst case, we just won't print the little "Test leaked" message,
	// but we'll still print any non-ignored leaked vars we found.
	int leaked_vars =
	found_vars - static_cast<int>(ignored_leaked_vars_.size());
	if (leaked_vars > 0) {
	std::ostringstream output;
	output << "Test leaked " << leaked_vars << " vars (printing at most "
	<< kVarsToPrint <<"):<p>";
	errors += output.str();
	}
	for (int i = 0; i < std::min(found_vars, kVarsToPrint); ++i) {
	pp::Var leaked_var(pp::PASS_REF, vars[i]);
	if (ignored_leaked_vars_.count(leaked_var.pp_var().value.as_id) == 0)
	errors += leaked_var.DebugString() + "<p>";
	}
	}
	return errors;
	}

	// static
	void TestCase::QuitMainMessageLoop(PP_Instance instance) {
	PP_Instance* heap_instance = new PP_Instance(instance);
	pp::CompletionCallback callback(&DoQuitMainMessageLoop, heap_instance);
	pp::Module::Get()->core()->CallOnMainThread(0, callback);
	}

	// static
	void TestCase::DoQuitMainMessageLoop(void* pp_instance, int32_t result) {
	PP_Instance* instance = static_cast<PP_Instance*>(pp_instance);
	GetTestingInterface()->QuitMessageLoop(*instance);
	delete instance;
	}

	void TestCase::RunOnThreadInternal(
	void (thread_func)(void),
	void* thread_param,
	const PPB_Testing_Private* testing_interface) {
	PP_Thread thread;
	PP_CreateThread(&thread, thread_func, thread_param);
	// Run a message loop so pepper calls can be dispatched. The background
	// thread will set result_ and make us Quit when it's done.
	testing_interface->RunMessageLoop(instance_->pp_instance());
	PP_JoinThread(thread);
	}