Ejemplo n.º 1
0
bool TestExtString::test_sscanf() {
  VS(f_sscanf(0, "SN/2350001", "SN/%d"), CREATE_VECTOR1(2350001));

  Variant out;
  VS(f_sscanf(0, "SN/2350001", "SN/%d", CREATE_VECTOR1(ref(out))), 1);
  VS(out, 2350001);
  return Count(true);
}
Ejemplo n.º 2
0
bool TestExtJson::test_json_decode() {
  Array arr = CREATE_MAP1("fbid", 101501853510151001LL);
  VS(f_json_decode(f_json_encode(arr), true), arr);

  VS(f_json_decode("{\"0\":{\"00\":0}}", true),
     CREATE_MAP1("0", CREATE_MAP1("00", 0)));

  VS(f_json_decode("{\"a\":1,\"b\":2.3,\"3\":\"test\"}", true),
     CREATE_MAP3("a", 1, "b", 2.3, 3, "test"));
  VS(f_json_decode("[\"a\",1,true,false,null]", true),
     CREATE_VECTOR5("a", 1, true, false, null));

  Object obj = f_json_decode("{\"a\":1,\"b\":2.3,\"3\":\"test\"}");
  Object obj2(SystemLib::AllocStdClassObject());
  obj2->o_set("a", 1);
  obj2->o_set("b", 2.3);
  obj2->o_set("3", "test");
  VS(obj.toArray(), obj2.toArray());

  obj = f_json_decode("[\"a\",1,true,false,null]");
  VS(obj.toArray(), CREATE_VECTOR5("a", 1, true, false, null));

  VS(f_json_decode("{z:1}",     true),       null);
  VS(f_json_decode("{z:1}",     true, k_JSON_FB_LOOSE), CREATE_MAP1("z", 1));
  VS(f_json_decode("{z:\"z\"}", true),       null);
  VS(f_json_decode("{z:\"z\"}", true, k_JSON_FB_LOOSE), CREATE_MAP1("z", "z"));
  VS(f_json_decode("{'x':1}",   true),       null);
  VS(f_json_decode("{'x':1}",   true, k_JSON_FB_LOOSE), CREATE_MAP1("x", 1));
  VS(f_json_decode("{y:1,}",    true),       null);
  VS(f_json_decode("{y:1,}",    true, k_JSON_FB_LOOSE), CREATE_MAP1("y", 1));
  VS(f_json_decode("{,}",       true),       null);
  VS(f_json_decode("{,}",       true, k_JSON_FB_LOOSE), null);
  VS(f_json_decode("[1,2,3,]",  true),       null);
  VS(f_json_decode("[1,2,3,]",  true, k_JSON_FB_LOOSE), CREATE_VECTOR3(1,2,3));
  VS(f_json_decode("[,]",       true),       null);
  VS(f_json_decode("[,]",       true, k_JSON_FB_LOOSE), null);
  VS(f_json_decode("[]",        true),       Array::Create());
  VS(f_json_decode("[]",        true, k_JSON_FB_LOOSE), Array::Create());
  VS(f_json_decode("{}",        true),       Array::Create());
  VS(f_json_decode("{}",        true, k_JSON_FB_LOOSE), Array::Create());
  VS(f_json_decode("test",      true),       null);
  VS(f_json_decode("test",      true, k_JSON_FB_LOOSE), "test");
  VS(f_json_decode("'test'",    true),       null);
  VS(f_json_decode("'test'",    true, k_JSON_FB_LOOSE), "test");
  VS(f_json_decode("\"test\"",  true),       "test");
  VS(f_json_decode("\"test\"",  true, k_JSON_FB_LOOSE), "test");

  VS(f_json_decode("[{\"a\":\"apple\"},{\"b\":\"banana\"}]", true),
     CREATE_VECTOR2(CREATE_MAP1("a", "apple"), CREATE_MAP1("b", "banana")));

  Variant a = "[{\"a\":[{\"n\":\"1st\"}]},{\"b\":[{\"n\":\"2nd\"}]}]";
  VS(f_json_decode(a, true),
     CREATE_VECTOR2
     (CREATE_MAP1("a", CREATE_VECTOR1(CREATE_MAP1("n", "1st"))),
      CREATE_MAP1("b", CREATE_VECTOR1(CREATE_MAP1("n", "2nd")))));

  return Count(true);
}
Ejemplo n.º 3
0
bool TestExtMb::test_mb_ereg_search_regs() {
  String str = "Pr\xC3\x9C\xC3\x9D""fung abc p\xC3\x9C";
  String reg = "\\w+";
  f_mb_regex_encoding("UTF-8");
  f_mb_ereg_search_init(str, reg);
  Variant r = f_mb_ereg_search();
  r = f_mb_ereg_search_getregs(); // get first result
  VS(r, CREATE_VECTOR1("Pr\xC3\x9C\xC3\x9D""fung"));
  r = f_mb_ereg_search_regs();    // get next result
  VS(r, CREATE_VECTOR1("abc"));
  return Count(true);
}
Ejemplo n.º 4
0
bool TestExtFb::test_fb_thrift_serialize() {
  Variant ret;
  VS(f_fb_thrift_unserialize(f_fb_thrift_serialize("test"), ref(ret)), "test");
  VERIFY(same(ret, true));

  ret = null;
  VS(f_fb_thrift_unserialize(f_fb_thrift_serialize(CREATE_VECTOR1("test")),
                             ref(ret)),
     CREATE_VECTOR1("test"));
  VERIFY(same(ret, true));
  return Count(true);
}
Ejemplo n.º 5
0
bool TestExtFb::test_fb_call_user_func_safe_return() {
  {
    Variant ret = f_fb_call_user_func_safe_return
      (1, "TEst", "ok", CREATE_VECTOR1("param"));
    VS(ret, "param");
  }
  {
    Variant ret = f_fb_call_user_func_safe_return
      (1, "NonTEst", "ok", CREATE_VECTOR1("param"));
    VS(ret, "ok");
  }
  return Count(true);
}
Ejemplo n.º 6
0
bool TestExtFb::test_fb_call_user_func_array_safe() {
  {
    Variant ret = f_fb_call_user_func_array_safe
      ("TEst", CREATE_VECTOR1("param"));
    VS(ret, CREATE_VECTOR2(true, "param"));
  }
  {
    Variant ret = f_fb_call_user_func_array_safe
      ("NonTest", CREATE_VECTOR1("param"));
    VS(ret, CREATE_VECTOR2(false, null));
  }
  return Count(true);
}
Ejemplo n.º 7
0
bool TestExtFb::test_fb_call_user_func_safe() {
  {
    Variant ret = f_fb_call_user_func_safe
      (1, "TEst", CREATE_VECTOR1("param"));
    VS(ret, CREATE_VECTOR2(true, "param"));
  }
  {
    Variant ret = f_fb_call_user_func_safe
      (1, "NonTEst", CREATE_VECTOR1("param"));
    VS(ret, CREATE_VECTOR2(false, uninit_null()));
  }
  return Count(true);
}
Ejemplo n.º 8
0
bool TestExtJson::test_json_encode() {
  VS(f_json_encode(CREATE_MAP3("a", 1, "b", 2.3, 3, "test")),
     "{\"a\":1,\"b\":2.3,\"3\":\"test\"}");
  VS(f_json_encode(CREATE_VECTOR5("a", 1, true, false, uninit_null())),
     "[\"a\",1,true,false,null]");

  VS(f_json_encode("a\xE0"), "null");
  VS(f_json_encode("a\xE0", k_JSON_FB_LOOSE), "\"a?\"");

  VS(f_json_encode(CREATE_MAP2("0", "apple", "1", "banana")),
     "[\"apple\",\"banana\"]");

  VS(f_json_encode(CREATE_VECTOR1(CREATE_MAP1("a", "apple"))),
     "[{\"a\":\"apple\"}]");

  VS(f_json_encode(CREATE_VECTOR1(CREATE_MAP1("a", "apple")),
                   k_JSON_PRETTY_PRINT),
    "[\n    {\n        \"a\": \"apple\"\n    }\n]");

  VS(f_json_encode(CREATE_VECTOR4(1, 2, 3, CREATE_VECTOR3(1, 2, 3)),
                   k_JSON_PRETTY_PRINT),
    "[\n"
    "    1,\n"
    "    2,\n"
    "    3,\n"
    "    [\n"
    "        1,\n"
    "        2,\n"
    "        3\n"
    "    ]\n"
    "]");

  Array arr = CREATE_MAP3(
    "a", 1,
    "b", CREATE_VECTOR2(1, 2),
    "c", CREATE_MAP1("d", 42)
  );
  VS(f_json_encode(arr, k_JSON_PRETTY_PRINT),
    "{\n"
    "    \"a\": 1,\n"
    "    \"b\": [\n"
    "        1,\n"
    "        2\n"
    "    ],\n"
    "    \"c\": {\n"
    "        \"d\": 42\n"
    "    }\n"
    "}");

  return Count(true);
}
Ejemplo n.º 9
0
bool TestExtMath::test_max() {
  VS(f_max(4, 2, CREATE_VECTOR4(3, 1, 6, 7)), 7);
  VS(f_max(0, CREATE_VECTOR3(2, 4, 5)), 5);
  VS(f_max(1, 0, CREATE_VECTOR1("hello")), 0);
  VS(f_max(1, "hello", CREATE_VECTOR1(0)), "hello");
  VS(f_max(1, "hello", CREATE_VECTOR1(-1)), "hello");
  VS(f_max(1, CREATE_VECTOR3(2, 4, 8),
           CREATE_VECTOR1(CREATE_VECTOR3(2, 5, 1))),
     CREATE_VECTOR3(2, 5, 1));
  VS(f_max(1, "string", CREATE_VECTOR2(CREATE_VECTOR3(2, 5, 7), 42)),
     CREATE_VECTOR3(2, 5, 7));
  VS(f_max(1, CREATE_MAP1(1, "1236150163")), "1236150163");
  return Count(true);
}
Ejemplo n.º 10
0
bool BaseExecutionContext::onUnhandledException(Object e) {
  String err = e.toString();
  if (RuntimeOption::AlwaysLogUnhandledExceptions) {
    Logger::Error("HipHop Fatal error: Uncaught %s", err.data());
  }

  if (e.instanceof("Exception")) {
    // user thrown exception
    if (!m_userExceptionHandlers.empty()) {
      if (!same(f_call_user_func_array
                (m_userExceptionHandlers.back(),
                 CREATE_VECTOR1(e)),
                false)) {
        return true;
      }
    }
  } else {
    ASSERT(false);
  }
  m_lastError = err;

  if (!RuntimeOption::AlwaysLogUnhandledExceptions) {
    Logger::Error("HipHop Fatal error: Uncaught %s", err.data());
  }
  return false;
}
Ejemplo n.º 11
0
Variant f_check_user_func_async(CVarRef handles, int timeout /* = -1 */) {
  if (handles.isArray()) {
    return FiberAsyncFunc::Status(handles, timeout);
  }
  Array ret = FiberAsyncFunc::Status(CREATE_VECTOR1(handles), timeout);
  return !ret.empty();
}
Ejemplo n.º 12
0
bool TestExtApc::test_apc_exists() {
  f_apc_store(s_ts, s_TestString);
  VS(f_apc_exists(s_ts), true);
  VS(f_apc_exists(s_TestString), false);
  VS(f_apc_exists(CREATE_VECTOR2(s_ts, s_TestString)), CREATE_VECTOR1(s_ts));
  return Count(true);
}
Ejemplo n.º 13
0
bool ExecutionContext::obFlush() {
  ASSERT(m_protectedLevel >= 0);
  if ((int)m_buffers.size() > m_protectedLevel) {
    list<OutputBuffer*>::const_iterator iter = m_buffers.end();
    OutputBuffer *last = *(--iter);
    if (iter != m_buffers.begin()) {
      OutputBuffer *prev = *(--iter);
      if (last->handler.isNull()) {
        prev->oss << last->oss.str();
      } else {
        try {
          string output = last->oss.str();
          String sout(output.data(), output.length(), AttachLiteral);
          Variant tout =
            f_call_user_func_array(last->handler, CREATE_VECTOR1(sout));
          sout = tout.toString();
          prev->oss << string(sout.data(), sout.size());
        } catch (...) {
          prev->oss << last->oss.str();
        }
      }
      last->oss.str("");
      return true;
    }
    cout << last->oss.str();
    last->oss.str("");
  }
  return false;
}
Ejemplo n.º 14
0
ObjectData* SystemLib::AllocBadMethodCallExceptionObject(CVarRef message) {
  if (hhvm) {
    CREATE_AND_CONSTRUCT(BadMethodCallException, CREATE_VECTOR1(message));
  } else {
    return (NEWOBJ(c_BadMethodCallException)())->create(message);
  }
}
Ejemplo n.º 15
0
ObjectData* SystemLib::AllocInvalidOperationExceptionObject(CVarRef message) {
  if (hhvm) {
    CREATE_AND_CONSTRUCT(InvalidOperationException, CREATE_VECTOR1(message));
  } else {
    return (NEWOBJ(c_InvalidOperationException)())->create(message);
  }
}
Ejemplo n.º 16
0
ObjectData* SystemLib::AllocOutOfBoundsExceptionObject(CVarRef message) {
  if (hhvm) {
    CREATE_AND_CONSTRUCT(OutOfBoundsException, CREATE_VECTOR1(message));
  } else {
    return (NEWOBJ(c_OutOfBoundsException)())->create(message);
  }
}
Ejemplo n.º 17
0
bool UserFile::lock(int operation, bool &wouldBlock) {
    int64_t op = 0;
    if (operation & LOCK_NB) {
        op |= k_LOCK_NB;
    }
    switch (operation & ~LOCK_NB) {
    case LOCK_SH:
        op |= k_LOCK_SH;
        break;
    case LOCK_EX:
        op |= k_LOCK_EX;
        break;
    case LOCK_UN:
        op |= k_LOCK_UN;
        break;
    }

    // bool stream_lock(int $operation)
    bool success = false;
    Variant ret = invoke(m_StreamLock, s_stream_lock,
                         CREATE_VECTOR1(op), success);
    if (!success) {
        if (operation) {
            raise_warning("%s::stream_lock is not implemented!",
                          m_cls->name()->data());
        }
        return false;
    }
    return ret.isBoolean() ? ret.toBoolean() : false;
}
Ejemplo n.º 18
0
bool TestExtApc::test_apc_exists() {
  f_apc_store("ts", "TestString");
  VS(f_apc_exists("ts"), true);
  VS(f_apc_exists("TestString"), false);
  VS(f_apc_exists(CREATE_VECTOR2("ts", "TestString")), CREATE_VECTOR1("ts"));
  return Count(true);
}
Ejemplo n.º 19
0
bool TestExtVariable::test_is_scalar() {
  VERIFY(f_is_scalar(123));
  VERIFY(f_is_scalar("test"));
  VERIFY(!f_is_scalar(uninit_null()));
  VERIFY(!f_is_scalar(CREATE_VECTOR1(123)));
  return Count(true);
}
Ejemplo n.º 20
0
Variant EvalObjectData::t___unset(Variant v_name) {
    const MethodStatement *ms = getMethodStatement("__unset");
    if (ms) {
        return ms->invokeInstance(Object(root), CREATE_VECTOR1(v_name), false);
    } else {
        return DynamicObjectData::t___unset(v_name);
    }
}
Ejemplo n.º 21
0
void CmdUser::invokeList(DebuggerClient *client, const std::string &cls) {
  p_DebuggerClient pclient(NEW(c_DebuggerClient)());
  pclient->m_client = client;
  try {
    Object cmd = create_object(cls.c_str(), null_array);
    cmd->o_invoke("onAutoComplete", CREATE_VECTOR1(pclient), -1);
  } catch (...) {}
}
Ejemplo n.º 22
0
static bool filter_func(CVarRef value, const void *data) {
  HPHP::VM::CallCtx* ctx = (HPHP::VM::CallCtx*)data;
  Variant ret;
  g_vmContext->invokeFunc((TypedValue*)&ret, ctx->func, CREATE_VECTOR1(value),
                          ctx->this_, ctx->cls,
                          NULL, ctx->invName);
  return ret.toBoolean();
}
Ejemplo n.º 23
0
bool TestExtCurl::test_evhttp_post() {
  Variant ret = f_evhttp_post(String(get_request_uri()), "echo",
                              CREATE_VECTOR1("ECHO: foo"));
  VS(ret[s_code], 200);
  VS(ret[s_response], "POST: echo");
  VS(ret[s_headers][0], "ECHOED: foo");
  VS(ret[s_headers][4], "Content-Length: 10");
  return Count(true);
}
Ejemplo n.º 24
0
void objOffsetUnset(TypedValue* base, CVarRef offset) {
  objArrayAccess(base);
  static StringData* sd__offsetUnset
    = StringData::GetStaticString("offsetUnset");
  ObjectData* obj = base->m_data.pobj;
  if (LIKELY(obj->isInstance())) {
    Instance* instance = static_cast<Instance*>(obj);
    const Func* method = instance->methodNamed(sd__offsetUnset);
    ASSERT(method != NULL);
    TypedValue tv;
    tvWriteUninit(&tv);
    instance->invokeUserMethod(&tv, method, CREATE_VECTOR1(offset));
    tvRefcountedDecRef(&tv);
  } else {
    tvAsVariant(base).getArrayAccess()
      ->o_invoke(sd__offsetUnset, CREATE_VECTOR1(offset));
  }
}
Ejemplo n.º 25
0
bool TestExtCurl::test_evhttp_get() {
  Variant ret = f_evhttp_get(String(get_request_uri()),
                             CREATE_VECTOR1("ECHO: foo"));
  VS(ret["code"], 200);
  VS(ret["response"], "OK");
  VS(ret["headers"][0], "ECHOED: foo");
  VS(ret["headers"][4], "Content-Length: 2");
  return Count(true);
}
Ejemplo n.º 26
0
Variant EvalObjectData::t___set_state(Variant v_properties) {
  const MethodStatement *ms = getMethodStatement("__set_state");
  if (ms) {
    return ms->invokeInstance(Object(root), CREATE_VECTOR1(v_properties),
        false);
  } else {
    return DynamicObjectData::t___set_state(v_properties);
  }
}
Ejemplo n.º 27
0
Variant &EvalObjectData::___offsetget_lval(Variant v_name) {
    const MethodStatement *ms = getMethodStatement("offsetget");
    if (ms) {
        Variant &v = get_globals()->__lvalProxy;
        v = ms->invokeInstance(Object(root), CREATE_VECTOR1(v_name), false);
        return v;
    } else {
        return DynamicObjectData::___offsetget_lval(v_name);
    }
}
Ejemplo n.º 28
0
bool CmdUser::invokeClient(DebuggerClient *client, const std::string &cls) {
  p_DebuggerClient pclient(NEW(c_DebuggerClient)());
  pclient->m_client = client;
  try {
    Object cmd = create_object(cls.c_str(), null_array);
    Variant ret = cmd->o_invoke("onClient", CREATE_VECTOR1(pclient), -1);
    return !same(ret, false);
  } catch (...) {}
  return false;
}
Ejemplo n.º 29
0
bool CmdUser::onServer(DebuggerProxy *proxy) {
  if (m_cmd.isNull()) return false;
  p_DebuggerProxy pproxy(NEW(c_DebuggerProxy)());
  pproxy->m_proxy = proxy;
  try {
    Variant ret = m_cmd->o_invoke("onServer", CREATE_VECTOR1(pproxy), -1);
    return !same(ret, false);
  } catch (...) {}
  return false;
}
Ejemplo n.º 30
0
bool objOffsetExists(TypedValue* base, CVarRef offset) {
  objArrayAccess(base);
  TypedValue tvResult;
  tvWriteUninit(&tvResult);
  static StringData* sd__offsetExists
    = StringData::GetStaticString("offsetExists");
  ObjectData* obj = base->m_data.pobj;
  if (LIKELY(obj->isInstance())) {
    Instance* instance = static_cast<Instance*>(obj);
    const Func* method = instance->methodNamed(sd__offsetExists);
    ASSERT(method != NULL);
    instance->invokeUserMethod(&tvResult, method, CREATE_VECTOR1(offset));
  } else {
    tvAsVariant(&tvResult) = tvAsVariant(base).getArrayAccess()
      ->o_invoke(sd__offsetExists, CREATE_VECTOR1(offset));
  }
  tvCastToBooleanInPlace(&tvResult);
  return bool(tvResult.m_data.num);
}