mock-ril/src/cpp/experiments.cpp - platform/hardware/ril - Git at Google

 /**
  * Copyright (C) 2010 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 <v8.h>
 #include "ril.h"

 #include "logging.h"
 #include "status.h"
 #include "worker.h"
 #include "util.h"

 #include "hardware/ril/mock-ril/src/proto/ril.pb.h"

 #include "logging.h"
 #include "js_support.h"
 #include "node_buffer.h"
 #include "node_util.h"
 #include "protobuf_v8.h"
 #include "requests.h"

 #include "experiments.h"

 void testStlPort() {
     // Test using STLport
     std::queue<int *> q;
     int data[] = {1, 2, 3};

     int *param = data;
     ALOGD("before push q.size=%d", q.size());
     q.push(param);
     ALOGD("after push q.size=%d", q.size());
     void *p = q.front();
     if (p == param) {
         ALOGD("q.push succeeded");
     } else {
         ALOGD("q.push failed");
     }
     q.pop();
     ALOGD("after pop q.size=%d", q.size());
 }

 v8::Handle<v8::Value> GetReqScreenState(v8::Local<v8::String> property,
                                const v8::AccessorInfo &info) {
     v8::Local<v8::Object> self = info.Holder();
     v8::Local<v8::External> wrap =
             v8::Local<v8::External>::Cast(self->GetInternalField(0));
     void *p = wrap->Value();
     int state = static_cast<int *>(p)[0];
     ALOGD("GetReqScreenState state=%d", state);
     return v8::Integer::New(state);
 }

 bool callOnRilRequest(v8::Handle<v8::Context> context, int request,
                    void *data, size_t datalen, RIL_Token t) {
     v8::HandleScope handle_scope;
     v8::TryCatch try_catch;

     // Get the onRilRequestFunction, making sure its a function
     v8::Handle<v8::String> name = v8::String::New("onRilRequest");
     v8::Handle<v8::Value> onRilRequestFunctionValue = context->Global()->Get(name);
     if(!onRilRequestFunctionValue->IsFunction()) {
         // Wasn't a function
         ALOGD("callOnRilRequest X wasn't a function");
         return false;
     }
     v8::Handle<v8::Function> onRilRequestFunction =
         v8::Handle<v8::Function>::Cast(onRilRequestFunctionValue);

     // Create the request
     v8::Handle<v8::Value> v8RequestValue = v8::Number::New(request);

     // Create the parameter for the request
     v8::Handle<v8::Object> params_obj =
             v8::ObjectTemplate::New()->NewInstance();
     switch(request) {
         case(RIL_REQUEST_SCREEN_STATE): {
             ALOGD("callOnRilRequest RIL_REQUEST_SCREEN_STATE");
             if (datalen < sizeof(int)) {
                 ALOGD("callOnRilRequest err size < sizeof int");
             } else {
                 v8::Handle<v8::ObjectTemplate> params_obj_template =
                         v8::ObjectTemplate::New();
                 params_obj_template->SetInternalFieldCount(1);
                 params_obj_template->SetAccessor(v8::String::New(
                             "ReqScreenState"), GetReqScreenState, NULL);
                 // How to not leak this pointer!!!
                 int *p = new int;
                 *p = ((int *)data)[0];
                 params_obj = params_obj_template->NewInstance();
                 params_obj->SetInternalField(0, v8::External::New(p));
             }
             break;
         }
         default: {
             ALOGD("callOnRilRequest X unknown request");
             break;
         }
     }

     // Invoke onRilRequest
     bool retValue;
     const int argc = 2;
     v8::Handle<v8::Value> argv[argc] = { v8RequestValue, params_obj };
     v8::Handle<v8::Value> result =
         onRilRequestFunction->Call(context->Global(), argc, argv);
     if (try_catch.HasCaught()) {
         ALOGD("callOnRilRequest error");
         ReportException(&try_catch);
         retValue = false;
     } else {
         v8::String::Utf8Value result_string(result);
         ALOGD("callOnRilRequest result=%s", ToCString(result_string));
         retValue = true;
     }
     return retValue;
 }

 void testOnRilRequestUsingCppRequestObjs(v8::Handle<v8::Context> context) {
     ALOGD("testOnRilRequestUsingCppRequestObjs E:");
     v8::HandleScope handle_scope;

     v8::TryCatch try_catch;
     try_catch.SetVerbose(true);

     runJs(context, &try_catch, "local-string",
         "function onRilRequest(reqNum, params) {\n"
         "  print(\"reqNum=\" + reqNum);\n"
         "  if (reqNum == 61) {\n"
         "      print(\"params.ReqScreenState=\" + params.ReqScreenState);\n"
         "  }\n"
         "  return \"Hello World\";\n"
         "}\n");
     if (!try_catch.HasCaught()) {
         // Call the onRilRequest function
         int data[1] = { 0 };
         callOnRilRequest(context, RIL_REQUEST_SCREEN_STATE, data,
                 sizeof(data), NULL);
     }
     ALOGD("testOnRilRequestUsingCppRequestObjs X:");
 }

 void testReqScreenStateProtobuf() {
     v8::HandleScope handle_scope;
     v8::TryCatch try_catch;

     ALOGD("testReqScreenStateProtobuf E");

     ALOGD("create ReqScreenState");
     ril_proto::ReqScreenState* ss = new ril_proto::ReqScreenState();
     ss->set_state(true);
     bool state = ss->state();
     ALOGD("state=%d", state);
     ss->set_state(false);
     state = ss->state();
     ALOGD("state=%d", state);
     int len = ss->ByteSize();
     ALOGD("create buffer len=%d", len);
     char *buffer = new char[len];
     ALOGD("serialize");
     bool ok = ss->SerializeToArray(buffer, len);
     if (!ok) {
         ALOGD("testReqScreenStateProtobuf X: Could not serialize ss");
         return;
     }
     ALOGD("ReqScreenState serialized ok");
     ril_proto::ReqScreenState *newSs = new ril_proto::ReqScreenState();
     ok = newSs->ParseFromArray(buffer, len);
     if (!ok) {
         ALOGD("testReqScreenStateProtobuf X: Could not deserialize ss");
         return;
     }
     ALOGD("newSs->state=%d", newSs->state());

     delete [] buffer;
     delete ss;
     delete newSs;
     ALOGD("testReqScreenStateProtobuf X");
 }

 void testReqHangUpProtobuf() {
     v8::HandleScope handle_scope;
     v8::TryCatch try_catch;

     ALOGD("testReqHangUpProtobuf E");

     ALOGD("create ReqHangUp");
     ril_proto::ReqHangUp* hu = new ril_proto::ReqHangUp();
     hu->set_connection_index(3);
     bool connection_index = hu->connection_index();
     ALOGD("connection_index=%d", connection_index);
     hu->set_connection_index(2);
     connection_index = hu->connection_index();
     ALOGD("connection_index=%d", connection_index);
     ALOGD("create buffer");
     int len = hu->ByteSize();
     char *buffer = new char[len];
     ALOGD("serialize");
     bool ok = hu->SerializeToArray(buffer, len);
     if (!ok) {
         ALOGD("testReqHangUpProtobuf X: Could not serialize hu");
         return;
     }
     ALOGD("ReqHangUp serialized ok");
     ril_proto::ReqHangUp *newHu = new ril_proto::ReqHangUp();
     ok = newHu->ParseFromArray(buffer, len);
     if (!ok) {
         ALOGD("testReqHangUpProtobuf X: Could not deserialize hu");
         return;
     }
     ALOGD("newHu->connection_index=%d", newHu->connection_index());

     delete [] buffer;
     delete hu;
     delete newHu;
     ALOGD("testReqHangUpProtobuf X");
 }

 void testProtobufV8(v8::Handle<v8::Context> context) {
     ALOGD("testProtobufV8 E:");
     v8::HandleScope handle_scope;

     v8::TryCatch try_catch;
     try_catch.SetVerbose(true);

     if (try_catch.HasCaught()) {
         ALOGD("TryCatch.hasCaught is true after protobuf_v8::init");
         ReportException(&try_catch);
     }
     runJs(context, &try_catch, "local-string",
         "fileContents = readFileToString('mock_ril.js');\n"
         "print('fileContents:\\n' + fileContents);\n"
         "\n"
         "buffer = readFileToBuffer('ril.desc');\n"
         "var schema = new Schema(buffer);\n"
         "\n"
         "var originalReqEnterSimPin = { pin : 'hello-the-pin' };\n"
         "print('originalReqEnterSimPin: pin=' + originalReqEnterSimPin.pin);\n"
         "var ReqEnterSimPinSchema = schema['ril_proto.ReqEnterSimPin'];\n"
         "serializedOriginalReqEnterSimPin = ReqEnterSimPinSchema.serialize(originalReqEnterSimPin);\n"
         "print('serializedOriginalReqEnterSimPin.length=' + serializedOriginalReqEnterSimPin.length);\n"
         "newReqEnterSimPin = ReqEnterSimPinSchema.parse(serializedOriginalReqEnterSimPin);\n"
         "print('newReqEnterSimPin: pin=' + newReqEnterSimPin.pin);\n"
         "\n"
         "var originalReqScreenState = { state : true };\n"
         "print('originalReqScreenState: state=' + originalReqScreenState.state);\n"
         "var ReqScreenStateSchema = schema['ril_proto.ReqScreenState'];\n"
         "var serializedOriginalReqScreenState = ReqScreenStateSchema.serialize(originalReqScreenState);\n"
         "print('serializedOriginalReqScreenState.length=' + serializedOriginalReqScreenState.length);\n"
         "var newReqScreenState = ReqScreenStateSchema.parse(serializedOriginalReqScreenState);\n"
         "print('newReqScreenState: state=' + newReqScreenState.state);\n"
         "\n"
         "originalReqScreenState.state = false;\n"
         "print('originalReqScreenState: state=' + originalReqScreenState.state);\n"
         "serializedOriginalReqScreenState = ReqScreenStateSchema.serialize(originalReqScreenState);\n"
         "print('serializedOriginalReqScreenState.length=' + serializedOriginalReqScreenState.length);\n"
         "newReqScreenState = ReqScreenStateSchema.parse(serializedOriginalReqScreenState);\n"
         "print('newReqScreenState: state=' + newReqScreenState.state);\n");
     ALOGD("testProtobufV8 X");
 }

 void experiments(v8::Handle<v8::Context> context) {
     ALOGD("experiments E: ********");
     testStlPort();
     testReqScreenStateProtobuf();
     testOnRilRequestUsingCppRequestObjs(context);
     testProtobufV8(context);
     ALOGD("experiments X: ********\n");
 }
	/**
	* Copyright (C) 2010 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 <v8.h>
	#include "ril.h"

	#include "logging.h"
	#include "status.h"
	#include "worker.h"
	#include "util.h"

	#include "hardware/ril/mock-ril/src/proto/ril.pb.h"

	#include "logging.h"
	#include "js_support.h"
	#include "node_buffer.h"
	#include "node_util.h"
	#include "protobuf_v8.h"
	#include "requests.h"

	#include "experiments.h"

	void testStlPort() {
	// Test using STLport
	std::queue<int *> q;
	int data[] = {1, 2, 3};

	int *param = data;
	ALOGD("before push q.size=%d", q.size());
	q.push(param);
	ALOGD("after push q.size=%d", q.size());
	void *p = q.front();
	if (p == param) {
	ALOGD("q.push succeeded");
	} else {
	ALOGD("q.push failed");
	}
	q.pop();
	ALOGD("after pop q.size=%d", q.size());
	}

	v8::Handle<v8::Value> GetReqScreenState(v8::Local<v8::String> property,
	const v8::AccessorInfo &info) {
	v8::Local<v8::Object> self = info.Holder();
	v8::Local<v8::External> wrap =
	v8::Local<v8::External>::Cast(self->GetInternalField(0));
	void *p = wrap->Value();
	int state = static_cast<int *>(p)[0];
	ALOGD("GetReqScreenState state=%d", state);
	return v8::Integer::New(state);
	}

	bool callOnRilRequest(v8::Handle<v8::Context> context, int request,
	void *data, size_t datalen, RIL_Token t) {
	v8::HandleScope handle_scope;
	v8::TryCatch try_catch;

	// Get the onRilRequestFunction, making sure its a function
	v8::Handle<v8::String> name = v8::String::New("onRilRequest");
	v8::Handle<v8::Value> onRilRequestFunctionValue = context->Global()->Get(name);
	if(!onRilRequestFunctionValue->IsFunction()) {
	// Wasn't a function
	ALOGD("callOnRilRequest X wasn't a function");
	return false;
	}
	v8::Handle<v8::Function> onRilRequestFunction =
	v8::Handle<v8::Function>::Cast(onRilRequestFunctionValue);

	// Create the request
	v8::Handle<v8::Value> v8RequestValue = v8::Number::New(request);

	// Create the parameter for the request
	v8::Handle<v8::Object> params_obj =
	v8::ObjectTemplate::New()->NewInstance();
	switch(request) {
	case(RIL_REQUEST_SCREEN_STATE): {
	ALOGD("callOnRilRequest RIL_REQUEST_SCREEN_STATE");
	if (datalen < sizeof(int)) {
	ALOGD("callOnRilRequest err size < sizeof int");
	} else {
	v8::Handle<v8::ObjectTemplate> params_obj_template =
	v8::ObjectTemplate::New();
	params_obj_template->SetInternalFieldCount(1);
	params_obj_template->SetAccessor(v8::String::New(
	"ReqScreenState"), GetReqScreenState, NULL);
	// How to not leak this pointer!!!
	int *p = new int;
	p = ((int )data)[0];
	params_obj = params_obj_template->NewInstance();
	params_obj->SetInternalField(0, v8::External::New(p));
	}
	break;
	}
	default: {
	ALOGD("callOnRilRequest X unknown request");
	break;
	}
	}

	// Invoke onRilRequest
	bool retValue;
	const int argc = 2;
	v8::Handle<v8::Value> argv[argc] = { v8RequestValue, params_obj };
	v8::Handle<v8::Value> result =
	onRilRequestFunction->Call(context->Global(), argc, argv);
	if (try_catch.HasCaught()) {
	ALOGD("callOnRilRequest error");
	ReportException(&try_catch);
	retValue = false;
	} else {
	v8::String::Utf8Value result_string(result);
	ALOGD("callOnRilRequest result=%s", ToCString(result_string));
	retValue = true;
	}
	return retValue;
	}

	void testOnRilRequestUsingCppRequestObjs(v8::Handle<v8::Context> context) {
	ALOGD("testOnRilRequestUsingCppRequestObjs E:");
	v8::HandleScope handle_scope;

	v8::TryCatch try_catch;
	try_catch.SetVerbose(true);

	runJs(context, &try_catch, "local-string",
	"function onRilRequest(reqNum, params) {\n"
	" print(\"reqNum=\" + reqNum);\n"
	" if (reqNum == 61) {\n"
	" print(\"params.ReqScreenState=\" + params.ReqScreenState);\n"
	" }\n"
	" return \"Hello World\";\n"
	"}\n");
	if (!try_catch.HasCaught()) {
	// Call the onRilRequest function
	int data[1] = { 0 };
	callOnRilRequest(context, RIL_REQUEST_SCREEN_STATE, data,
	sizeof(data), NULL);
	}
	ALOGD("testOnRilRequestUsingCppRequestObjs X:");
	}

	void testReqScreenStateProtobuf() {
	v8::HandleScope handle_scope;
	v8::TryCatch try_catch;

	ALOGD("testReqScreenStateProtobuf E");

	ALOGD("create ReqScreenState");
	ril_proto::ReqScreenState* ss = new ril_proto::ReqScreenState();
	ss->set_state(true);
	bool state = ss->state();
	ALOGD("state=%d", state);
	ss->set_state(false);
	state = ss->state();
	ALOGD("state=%d", state);
	int len = ss->ByteSize();
	ALOGD("create buffer len=%d", len);
	char *buffer = new char[len];
	ALOGD("serialize");
	bool ok = ss->SerializeToArray(buffer, len);
	if (!ok) {
	ALOGD("testReqScreenStateProtobuf X: Could not serialize ss");
	return;
	}
	ALOGD("ReqScreenState serialized ok");
	ril_proto::ReqScreenState *newSs = new ril_proto::ReqScreenState();
	ok = newSs->ParseFromArray(buffer, len);
	if (!ok) {
	ALOGD("testReqScreenStateProtobuf X: Could not deserialize ss");
	return;
	}
	ALOGD("newSs->state=%d", newSs->state());

	delete [] buffer;
	delete ss;
	delete newSs;
	ALOGD("testReqScreenStateProtobuf X");
	}

	void testReqHangUpProtobuf() {
	v8::HandleScope handle_scope;
	v8::TryCatch try_catch;

	ALOGD("testReqHangUpProtobuf E");

	ALOGD("create ReqHangUp");
	ril_proto::ReqHangUp* hu = new ril_proto::ReqHangUp();
	hu->set_connection_index(3);
	bool connection_index = hu->connection_index();
	ALOGD("connection_index=%d", connection_index);
	hu->set_connection_index(2);
	connection_index = hu->connection_index();
	ALOGD("connection_index=%d", connection_index);
	ALOGD("create buffer");
	int len = hu->ByteSize();
	char *buffer = new char[len];
	ALOGD("serialize");
	bool ok = hu->SerializeToArray(buffer, len);
	if (!ok) {
	ALOGD("testReqHangUpProtobuf X: Could not serialize hu");
	return;
	}
	ALOGD("ReqHangUp serialized ok");
	ril_proto::ReqHangUp *newHu = new ril_proto::ReqHangUp();
	ok = newHu->ParseFromArray(buffer, len);
	if (!ok) {
	ALOGD("testReqHangUpProtobuf X: Could not deserialize hu");
	return;
	}
	ALOGD("newHu->connection_index=%d", newHu->connection_index());

	delete [] buffer;
	delete hu;
	delete newHu;
	ALOGD("testReqHangUpProtobuf X");
	}

	void testProtobufV8(v8::Handle<v8::Context> context) {
	ALOGD("testProtobufV8 E:");
	v8::HandleScope handle_scope;

	v8::TryCatch try_catch;
	try_catch.SetVerbose(true);

	if (try_catch.HasCaught()) {
	ALOGD("TryCatch.hasCaught is true after protobuf_v8::init");
	ReportException(&try_catch);
	}
	runJs(context, &try_catch, "local-string",
	"fileContents = readFileToString('mock_ril.js');\n"
	"print('fileContents:\\n' + fileContents);\n"
	"\n"
	"buffer = readFileToBuffer('ril.desc');\n"
	"var schema = new Schema(buffer);\n"
	"\n"
	"var originalReqEnterSimPin = { pin : 'hello-the-pin' };\n"
	"print('originalReqEnterSimPin: pin=' + originalReqEnterSimPin.pin);\n"
	"var ReqEnterSimPinSchema = schema['ril_proto.ReqEnterSimPin'];\n"
	"serializedOriginalReqEnterSimPin = ReqEnterSimPinSchema.serialize(originalReqEnterSimPin);\n"
	"print('serializedOriginalReqEnterSimPin.length=' + serializedOriginalReqEnterSimPin.length);\n"
	"newReqEnterSimPin = ReqEnterSimPinSchema.parse(serializedOriginalReqEnterSimPin);\n"
	"print('newReqEnterSimPin: pin=' + newReqEnterSimPin.pin);\n"
	"\n"
	"var originalReqScreenState = { state : true };\n"
	"print('originalReqScreenState: state=' + originalReqScreenState.state);\n"
	"var ReqScreenStateSchema = schema['ril_proto.ReqScreenState'];\n"
	"var serializedOriginalReqScreenState = ReqScreenStateSchema.serialize(originalReqScreenState);\n"
	"print('serializedOriginalReqScreenState.length=' + serializedOriginalReqScreenState.length);\n"
	"var newReqScreenState = ReqScreenStateSchema.parse(serializedOriginalReqScreenState);\n"
	"print('newReqScreenState: state=' + newReqScreenState.state);\n"
	"\n"
	"originalReqScreenState.state = false;\n"
	"print('originalReqScreenState: state=' + originalReqScreenState.state);\n"
	"serializedOriginalReqScreenState = ReqScreenStateSchema.serialize(originalReqScreenState);\n"
	"print('serializedOriginalReqScreenState.length=' + serializedOriginalReqScreenState.length);\n"
	"newReqScreenState = ReqScreenStateSchema.parse(serializedOriginalReqScreenState);\n"
	"print('newReqScreenState: state=' + newReqScreenState.state);\n");
	ALOGD("testProtobufV8 X");
	}

	void experiments(v8::Handle<v8::Context> context) {
	ALOGD("experiments E: ********");
	testStlPort();
	testReqScreenStateProtobuf();
	testOnRilRequestUsingCppRequestObjs(context);
	testProtobufV8(context);
	ALOGD("experiments X: ********\n");
	}