oj 3.11.0 → 3.16.5

data/ext/oj/hash_test.c

@@ -1,484 +0,0 @@
-// Copyright (c) 2011 Peter Ohler. All rights reserved.
-
-// if windows, comment out the whole file. It's only a performance test.
-#ifndef _WIN32
-#include <sys/time.h>
-#include <time.h>
-#include "hash.h"
-#include <stdint.h>
-
-/* Define printf formats for standard types, like PRIu64 for uint64_t. */
-#define __STDC_FORMAT_MACROS
-#include <inttypes.h>
-
-typedef struct _strLen {
-    const char	*str;
-    size_t	len;
-} *StrLen;
-
-static struct _strLen data[] = {
-    { "Gem::Version", 12 },
-    { "TracePoint", 10 },
-    { "Complex::compatible", 19 },
-    { "Complex", 7 },
-    { "Rational::compatible", 20 },
-    { "Rational", 8 },
-    { "FiberError", 10 },
-    { "Fiber", 5 },
-    { "ThreadError", 11 },
-    { "Mutex", 5 },
-    { "ThreadGroup", 11 },
-    { "RubyVM::InstructionSequence", 27 },
-    { "Thread::Backtrace::Location", 27 },
-    { "Thread::Backtrace", 17 },
-    { "Thread", 6 },
-    { "RubyVM::Env", 11 },
-    { "RubyVM", 6 },
-    { "Enumerator::Yielder", 19 },
-    { "Enumerator::Generator", 21 },
-    { "StopIteration", 13 },
-    { "Enumerator::Lazy", 16 },
-    { "Enumerator", 10 },
-    { "ObjectSpace::WeakMap", 20 },
-    { "Math::DomainError", 17 },
-    { "Binding", 7 },
-    { "UnboundMethod", 13 },
-    { "Method", 6 },
-    { "SystemStackError", 16 },
-    { "LocalJumpError", 14 },
-    { "Proc", 4 },
-    { "Struct::Tms", 11 },
-    { "Process::Status", 15 },
-    { "Random", 6 },
-    { "Time", 4 },
-    { "Dir", 3 },
-    { "File::Stat", 10 },
-    { "File", 4 },
-    { "ARGF.class", 10 },
-    { "IO", 2 },
-    { "EOFError", 8 },
-    { "IOError", 7 },
-    { "Range", 5 },
-    { "Encoding::Converter", 19 },
-    { "Encoding::ConverterNotFoundError", 32 },
-    { "Encoding::InvalidByteSequenceError", 34 },
-    { "Encoding::UndefinedConversionError", 34 },
-    { "MatchData", 9 },
-    { "Regexp", 6 },
-    { "RegexpError", 11 },
-    { "Struct", 6 },
-    { "Hash", 4 },
-    { "Array", 5 },
-    { "Errno::ERPCMISMATCH", 19 },
-    { "Errno::EPROGUNAVAIL", 19 },
-    { "Errno::EPROGMISMATCH", 20 },
-    { "Errno::EPROCUNAVAIL", 19 },
-    { "Errno::EPROCLIM", 15 },
-    { "Errno::ENOTSUP", 14 },
-    { "Errno::ENOATTR", 14 },
-    { "Errno::ENEEDAUTH", 16 },
-    { "Errno::EFTYPE", 13 },
-    { "Errno::EBADRPC", 14 },
-    { "Errno::EAUTH", 12 },
-    { "Errno::EOWNERDEAD", 17 },
-    { "Errno::ENOTRECOVERABLE", 22 },
-    { "Errno::ECANCELED", 16 },
-    { "Errno::EDQUOT", 13 },
-    { "Errno::ESTALE", 13 },
-    { "Errno::EINPROGRESS", 18 },
-    { "Errno::EALREADY", 15 },
-    { "Errno::EHOSTUNREACH", 19 },
-    { "Errno::EHOSTDOWN", 16 },
-    { "Errno::ECONNREFUSED", 19 },
-    { "Errno::ETIMEDOUT", 16 },
-    { "Errno::ETOOMANYREFS", 19 },
-    { "Errno::ESHUTDOWN", 16 },
-    { "Errno::ENOTCONN", 15 },
-    { "Errno::EISCONN", 14 },
-    { "Errno::ENOBUFS", 14 },
-    { "Errno::ECONNRESET", 17 },
-    { "Errno::ECONNABORTED", 19 },
-    { "Errno::ENETRESET", 16 },
-    { "Errno::ENETUNREACH", 18 },
-    { "Errno::ENETDOWN", 15 },
-    { "Errno::EADDRNOTAVAIL", 20 },
-    { "Errno::EADDRINUSE", 17 },
-    { "Errno::EAFNOSUPPORT", 19 },
-    { "Errno::EPFNOSUPPORT", 19 },
-    { "Errno::EOPNOTSUPP", 17 },
-    { "Errno::ESOCKTNOSUPPORT", 22 },
-    { "Errno::EPROTONOSUPPORT", 22 },
-    { "Errno::ENOPROTOOPT", 18 },
-    { "Errno::EPROTOTYPE", 17 },
-    { "Errno::EMSGSIZE", 15 },
-    { "Errno::EDESTADDRREQ", 19 },
-    { "Errno::ENOTSOCK", 15 },
-    { "Errno::EUSERS", 13 },
-    { "Errno::EILSEQ", 13 },
-    { "Errno::EOVERFLOW", 16 },
-    { "Errno::EBADMSG", 14 },
-    { "Errno::EMULTIHOP", 16 },
-    { "Errno::EPROTO", 13 },
-    { "Errno::ENOLINK", 14 },
-    { "Errno::EREMOTE", 14 },
-    { "Errno::ENOSR", 12 },
-    { "Errno::ETIME", 12 },
-    { "Errno::ENODATA", 14 },
-    { "Errno::ENOSTR", 13 },
-    { "Errno::EIDRM", 12 },
-    { "Errno::ENOMSG", 13 },
-    { "Errno::ELOOP", 12 },
-    { "Errno::ENOTEMPTY", 16 },
-    { "Errno::ENOSYS", 13 },
-    { "Errno::ENOLCK", 13 },
-    { "Errno::ENAMETOOLONG", 19 },
-    { "Errno::EDEADLK", 14 },
-    { "Errno::ERANGE", 13 },
-    { "Errno::EDOM", 11 },
-    { "Errno::EPIPE", 12 },
-    { "Errno::EMLINK", 13 },
-    { "Errno::EROFS", 12 },
-    { "Errno::ESPIPE", 13 },
-    { "Errno::ENOSPC", 13 },
-    { "Errno::EFBIG", 12 },
-    { "Errno::ETXTBSY", 14 },
-    { "Errno::ENOTTY", 13 },
-    { "Errno::EMFILE", 13 },
-    { "Errno::ENFILE", 13 },
-    { "Errno::EINVAL", 13 },
-    { "Errno::EISDIR", 13 },
-    { "Errno::ENOTDIR", 14 },
-    { "Errno::ENODEV", 13 },
-    { "Errno::EXDEV", 12 },
-    { "Errno::EEXIST", 13 },
-    { "Errno::EBUSY", 12 },
-    { "Errno::ENOTBLK", 14 },
-    { "Errno::EFAULT", 13 },
-    { "Errno::EACCES", 13 },
-    { "Errno::ENOMEM", 13 },
-    { "Errno::EAGAIN", 13 },
-    { "Errno::ECHILD", 13 },
-    { "Errno::EBADF", 12 },
-    { "Errno::ENOEXEC", 14 },
-    { "Errno::E2BIG", 12 },
-    { "Errno::ENXIO", 12 },
-    { "Errno::EIO", 10 },
-    { "Errno::EINTR", 12 },
-    { "Errno::ESRCH", 12 },
-    { "Errno::ENOENT", 13 },
-    { "Errno::EPERM", 12 },
-    { "Errno::NOERROR", 14 },
-    { "Bignum", 6 },
-    { "Float", 5 },
-    { "Fixnum", 6 },
-    { "Integer", 7 },
-    { "Numeric", 7 },
-    { "FloatDomainError", 16 },
-    { "ZeroDivisionError", 17 },
-    { "SystemCallError", 15 },
-    { "Encoding::CompatibilityError", 28 },
-    { "EncodingError", 13 },
-    { "NoMemoryError", 13 },
-    { "SecurityError", 13 },
-    { "RuntimeError", 12 },
-    { "NoMethodError", 13 },
-    { "NameError::message", 18 },
-    { "NameError", 9 },
-    { "NotImplementedError", 19 },
-    { "LoadError", 9 },
-    { "SyntaxError", 11 },
-    { "ScriptError", 11 },
-    { "RangeError", 10 },
-    { "KeyError", 8 },
-    { "IndexError", 10 },
-    { "ArgumentError", 13 },
-    { "TypeError", 9 },
-    { "StandardError", 13 },
-    { "Interrupt", 9 },
-    { "SignalException", 15 },
-    { "SystemExit", 10 },
-    { "Exception", 9 },
-    { "Symbol", 6 },
-    { "String", 6 },
-    { "Encoding", 8 },
-    { "FalseClass", 10 },
-    { "TrueClass", 9 },
-    { "Data", 4 },
-    { "NilClass", 8 },
-    { "Class", 5 },
-    { "Module", 6 },
-    { "Object", 6 },
-    { "BasicObject", 11 },
-    { "Gem::Requirement::BadRequirementError", 37 },
-    { "Gem::Requirement", 16 },
-    { "Gem::SourceFetchProblem", 23 },
-    { "Gem::PlatformMismatch", 21 },
-    { "Gem::ErrorReason", 16 },
-    { "Gem::LoadError", 14 },
-    { "Gem::RemoteSourceException", 26 },
-    { "Gem::RemoteInstallationSkipped", 30 },
-    { "Gem::RemoteInstallationCancelled", 32 },
-    { "Gem::RemoteError", 16 },
-    { "Gem::OperationNotSupportedError", 31 },
-    { "Gem::InvalidSpecificationException", 34 },
-    { "Gem::InstallError", 17 },
-    { "Gem::Specification", 18 },
-    { "Date", 4 },
-    { "Gem::Platform", 13 },
-    { "Gem::SpecificGemNotFoundException", 33 },
-    { "Gem::GemNotFoundException", 25 },
-    { "Gem::FormatException", 20 },
-    { "Gem::FilePermissionError", 24 },
-    { "Gem::EndOfYAMLException", 23 },
-    { "Gem::DocumentError", 18 },
-    { "Gem::GemNotInHomeException", 26 },
-    { "Gem::DependencyRemovalException", 31 },
-    { "Gem::DependencyError", 20 },
-    { "Gem::CommandLineError", 21 },
-    { "Gem::Exception", 14 },
-    { "IRB::SLex", 9 },
-    { "IRB::Notifier::NoMsgNotifier", 28 },
-    { "IRB::Notifier::LeveledNotifier", 30 },
-    { "IRB::Notifier::CompositeNotifier", 32 },
-    { "IRB::Notifier::AbstractNotifier", 31 },
-    { "IRB::Notifier::ErrUnrecognizedLevel", 35 },
-    { "IRB::Notifier::ErrUndefinedNotifier", 35 },
-    { "IRB::StdioOutputMethod", 22 },
-    { "IRB::OutputMethod::NotImplementedError", 38 },
-    { "IRB::OutputMethod", 17 },
-    { "IRB::IllegalRCGenerator", 23 },
-    { "IRB::UndefinedPromptMode", 24 },
-    { "IRB::CantChangeBinding", 22 },
-    { "IRB::CantShiftToMultiIrbMode", 28 },
-    { "IRB::NoSuchJob", 14 },
-    { "IRB::IrbSwitchedToCurrentThread", 31 },
-    { "IRB::IrbAlreadyDead", 19 },
-    { "IRB::IllegalParameter", 21 },
-    { "IRB::CantReturnToNormalMode", 27 },
-    { "IRB::NotImplementedError", 24 },
-    { "IRB::UnrecognizedSwitch", 23 },
-    { "IRB::Irb", 8 },
-    { "IRB::Abort", 10 },
-    { "IRB::Locale", 11 },
-    { "IRB::SLex::ErrNodeNothing", 25 },
-    { "IRB::SLex::ErrNodeAlreadyExists", 31 },
-    { "RubyLex", 7 },
-    { "IRB::SLex::Node", 15 },
-    { "Gem::SystemExitException", 24 },
-    { "Gem::VerificationError", 22 },
-    { "RubyToken::TkError", 18 },
-    { "RubyToken::TkUnknownChar", 24 },
-    { "RubyToken::TkOPASGN", 19 },
-    { "RubyToken::TkOp", 15 },
-    { "RubyToken::TkVal", 16 },
-    { "RubyToken::TkId", 15 },
-    { "RubyToken::TkNode", 17 },
-    { "RubyToken::Token", 16 },
-    { "RubyToken::TkUNDEF", 18 },
-    { "RubyToken::TkDEF", 16 },
-    { "RubyToken::TkMODULE", 19 },
-    { "RubyToken::TkCLASS", 18 },
-    { "RubyToken::TkWHILE", 18 },
-    { "RubyToken::TkWHEN", 17 },
-    { "RubyToken::TkCASE", 17 },
-    { "RubyToken::TkELSE", 17 },
-    { "RubyToken::TkELSIF", 18 },
-    { "RubyToken::TkTHEN", 17 },
-    { "RubyToken::TkUNLESS", 19 },
-    { "RubyToken::TkIF", 15 },
-    { "RubyToken::TkEND", 16 },
-    { "RubyToken::TkENSURE", 19 },
-    { "RubyToken::TkRESCUE", 19 },
-    { "RubyToken::TkBEGIN", 18 },
-    { "RubyToken::TkDO", 15 },
-    { "RubyToken::TkIN", 15 },
-    { "RubyToken::TkRETRY", 18 },
-    { "RubyToken::TkREDO", 17 },
-    { "RubyToken::TkNEXT", 17 },
-    { "RubyToken::TkBREAK", 18 },
-    { "RubyToken::TkFOR", 16 },
-    { "RubyToken::TkUNTIL", 18 },
-    { "RubyToken::TkTRUE", 17 },
-    { "RubyToken::TkNIL", 16 },
-    { "RubyToken::TkSELF", 17 },
-    { "RubyToken::TkSUPER", 18 },
-    { "RubyToken::TkYIELD", 18 },
-    { "RubyToken::TkRETURN", 19 },
-    { "RubyToken::TkAND", 16 },
-    { "RubyToken::TkFALSE", 18 },
-    { "RubyToken::TkUNLESS_MOD", 23 },
-    { "RubyToken::TkIF_MOD", 19 },
-    { "RubyToken::TkNOT", 16 },
-    { "RubyToken::TkOR", 15 },
-    { "RubyToken::TkALIAS", 18 },
-    { "RubyToken::TkUNTIL_MOD", 22 },
-    { "RubyToken::TkWHILE_MOD", 22 },
-    { "RubyToken::TkGVAR", 17 },
-    { "RubyToken::TkFID", 16 },
-    { "RubyToken::TkIDENTIFIER", 23 },
-    { "RubyToken::Tk__FILE__", 21 },
-    { "RubyToken::Tk__LINE__", 21 },
-    { "RubyToken::TklEND", 17 },
-    { "RubyToken::TklBEGIN", 19 },
-    { "RubyToken::TkDEFINED", 20 },
-    { "RubyToken::TkDREGEXP", 20 },
-    { "RubyToken::TkDXSTRING", 21 },
-    { "RubyToken::TkDSTRING", 20 },
-    { "RubyToken::TkSYMBOL", 19 },
-    { "RubyToken::TkREGEXP", 19 },
-    { "RubyToken::TkXSTRING", 20 },
-    { "RubyToken::TkSTRING", 19 },
-    { "RubyToken::TkFLOAT", 18 },
-    { "RubyToken::TkINTEGER", 20 },
-    { "RubyToken::TkCONSTANT", 21 },
-    { "RubyToken::TkIVAR", 17 },
-    { "RubyToken::TkCVAR", 17 },
-    { "RubyToken::TkNEQ", 16 },
-    { "RubyToken::TkEQQ", 16 },
-    { "RubyToken::TkEQ", 15 },
-    { "RubyToken::TkCMP", 16 },
-    { "RubyToken::TkPOW", 16 },
-    { "RubyToken::TkUMINUS", 19 },
-    { "RubyToken::TkUPLUS", 18 },
-    { "Exception2MessageMapper::ErrNotRegisteredException", 50 },
-    { "RubyToken::TkBACK_REF", 21 },
-    { "RubyToken::TkNTH_REF", 20 },
-    { "RubyToken::TkLSHFT", 18 },
-    { "RubyToken::TkASET", 17 },
-    { "RubyToken::TkAREF", 17 },
-    { "RubyToken::TkDOT3", 17 },
-    { "RubyToken::TkDOT2", 17 },
-    { "RubyToken::TkNMATCH", 19 },
-    { "RubyToken::TkMATCH", 18 },
-    { "RubyToken::TkOROP", 17 },
-    { "RubyToken::TkANDOP", 18 },
-    { "RubyToken::TkLEQ", 16 },
-    { "RubyToken::TkGEQ", 16 },
-    { "RubyToken::TkAMPER", 18 },
-    { "RubyToken::TkSTAR", 17 },
-    { "RubyToken::TkfLBRACE", 20 },
-    { "RubyToken::TkfLBRACK", 20 },
-    { "RubyToken::TkfLPAREN", 20 },
-    { "RubyToken::TkCOLON", 18 },
-    { "RubyToken::TkQUESTION", 21 },
-    { "RubyToken::TkASSOC", 18 },
-    { "RubyToken::TkCOLON3", 19 },
-    { "RubyToken::TkCOLON2", 19 },
-    { "RubyToken::TkRSHFT", 18 },
-    { "RubyToken::TkBITAND", 19 },
-    { "RubyToken::TkBITXOR", 19 },
-    { "RubyToken::TkBITOR", 18 },
-    { "RubyToken::TkMOD", 16 },
-    { "RubyToken::TkDIV", 16 },
-    { "RubyToken::TkMULT", 17 },
-    { "RubyToken::TkMINUS", 18 },
-    { "RubyToken::TkPLUS", 17 },
-    { "RubyToken::TkLT", 15 },
-    { "RubyToken::TkGT", 15 },
-    { "RubyToken::TkSYMBEG", 19 },
-    { "IRB::DefaultEncodings", 21 },
-    { "RubyToken::TkRPAREN", 19 },
-    { "RubyToken::TkLBRACE", 19 },
-    { "RubyToken::TkLBRACK", 19 },
-    { "RubyToken::TkLPAREN", 19 },
-    { "RubyToken::TkDOT", 16 },
-    { "RubyToken::TkASSIGN", 19 },
-    { "RubyToken::TkBACKQUOTE", 22 },
-    { "RubyToken::TkNOTOP", 18 },
-    { "RubyToken::TkBITNOT", 19 },
-    { "RubyToken::TkDOLLAR", 19 },
-    { "RubyToken::TkAT", 15 },
-    { "RubyToken::TkBACKSLASH", 22 },
-    { "RubyToken::TkEND_OF_SCRIPT", 26 },
-    { "RubyToken::TkNL", 15 },
-    { "RubyToken::TkSPACE", 18 },
-    { "RubyToken::TkRD_COMMENT", 23 },
-    { "RubyToken::TkCOMMENT", 20 },
-    { "RubyToken::TkSEMICOLON", 22 },
-    { "RubyToken::TkCOMMA", 18 },
-    { "RubyToken::TkRBRACE", 19 },
-    { "RubyToken::TkRBRACK", 19 },
-    { "RubyLex::TerminateLineInput", 27 },
-    { "RubyLex::SyntaxError", 20 },
-    { "RubyLex::TkReading2TokenDuplicateError", 38 },
-    { "RubyLex::TkSymbol2TokenNoKey", 28 },
-    { "RubyLex::TkReading2TokenNoKey", 29 },
-    { "RubyLex::AlreadyDefinedToken", 28 },
-    { "IRB::FileInputMethod", 20 },
-    { "IRB::StdioInputMethod", 21 },
-    { "IRB::InputMethod", 16 },
-    { "IRB::ReadlineInputMethod", 24 },
-    { "IRB::Context", 12 },
-    { "IRB::Inspector", 14 },
-    { "IRB::WorkSpace", 14 },
-    { 0, 0 }
-};
-
-static uint64_t
-micro_time() {
-    struct timeval	tv;
-
-    gettimeofday(&tv, NULL);
-
-    return (uint64_t)tv.tv_sec * 1000000ULL + (uint64_t)tv.tv_usec;
-}
-
-static void
-perf() {
-    StrLen	d;
-    VALUE	v;
-    VALUE	*slot = 0;
-    uint64_t	dt, start;
-    int		i, iter = 1000000;
-    int		dataCnt = sizeof(data) / sizeof(*data);
-
-    oj_hash_init();
-    start = micro_time();
-    for (i = iter; 0 < i; i--) {
-	for (d = data; 0 != d->str; d++) {
-	    v = oj_class_hash_get(d->str, d->len, &slot);
-	    if (Qundef == v) {
-		if (0 != slot) {
-		    v = ID2SYM(rb_intern(d->str));
-		    *slot = v;
-		}
-	    }
-	}
-    }
-    dt = micro_time() - start;
-#if IS_WINDOWS
-    printf("%d iterations took %ld msecs, %ld gets/msec\n", iter, (long)(dt / 1000), (long)(iter * dataCnt / (dt / 1000)));
-#else
-    printf("%d iterations took %"PRIu64" msecs, %ld gets/msec\n", iter, dt / 1000, (long)(iter * dataCnt / (dt / 1000)));
-#endif
-}
-
-void
-oj_hash_test() {
-    StrLen	d;
-    VALUE	v;
-    VALUE	*slot = 0;;
-
-    oj_hash_init();
-    for (d = data; 0 != d->str; d++) {
-	char	*s = oj_strndup(d->str, d->len);
-	v = oj_class_hash_get(d->str, d->len, &slot);
-	if (Qnil == v) {
-	    if (0 == slot) {
-		printf("*** failed to get a slot for %s\n", s);
-	    } else {
-		v = ID2SYM(rb_intern(d->str));
-		*slot = v;
-	    }
-	} else {
-	    VALUE	rs = rb_funcall2(v, rb_intern("to_s"), 0, 0);
-
-	    printf("*** get on '%s' returned '%s' (%s)\n", s, StringValuePtr(rs), rb_class2name(rb_obj_class(v)));
-	}
-	/*oj_hash_print(c);*/
-    }
-    printf("*** ---------- hash table ------------\n");
-    oj_hash_print();
-    perf();
-}
-#endif

data/test/activesupport4/decoding_test.rb

@@ -1,108 +0,0 @@
-# encoding: utf-8
-require 'activesupport4/test_helper'
-require 'active_support/json'
-require 'active_support/time'
-
-class TestJSONDecoding < ActiveSupport::TestCase
-  class Foo
-    def self.json_create(object)
-      "Foo"
-    end
-  end
-
-  TESTS = {
-    %q({"returnTo":{"\/categories":"\/"}})        => {"returnTo" => {"/categories" => "/"}},
-    %q({"return\\"To\\":":{"\/categories":"\/"}}) => {"return\"To\":" => {"/categories" => "/"}},
-    %q({"returnTo":{"\/categories":1}})          => {"returnTo" => {"/categories" => 1}},
-    %({"returnTo":[1,"a"]})                    => {"returnTo" => [1, "a"]},
-    %({"returnTo":[1,"\\"a\\",", "b"]})        => {"returnTo" => [1, "\"a\",", "b"]},
-    %({"a": "'", "b": "5,000"})                  => {"a" => "'", "b" => "5,000"},
-    %({"a": "a's, b's and c's", "b": "5,000"})   => {"a" => "a's, b's and c's", "b" => "5,000"},
-    # multibyte
-    %({"matzue": "松江", "asakusa": "浅草"}) => {"matzue" => "松江", "asakusa" => "浅草"},
-    %({"a": "2007-01-01"})                       => {'a' => Date.new(2007, 1, 1)},
-    %({"a": "2007-01-01 01:12:34 Z"})            => {'a' => Time.utc(2007, 1, 1, 1, 12, 34)},
-    %(["2007-01-01 01:12:34 Z"])                 => [Time.utc(2007, 1, 1, 1, 12, 34)],
-    %(["2007-01-01 01:12:34 Z", "2007-01-01 01:12:35 Z"]) => [Time.utc(2007, 1, 1, 1, 12, 34), Time.utc(2007, 1, 1, 1, 12, 35)],
-    # no time zone
-    %({"a": "2007-01-01 01:12:34"})              => {'a' => "2007-01-01 01:12:34"},
-    # invalid date
-    %({"a": "1089-10-40"})                       => {'a' => "1089-10-40"},
-    # xmlschema date notation
-    %({"a": "2009-08-10T19:01:02Z"})             => {'a' => Time.utc(2009, 8, 10, 19, 1, 2)},
-    %({"a": "2009-08-10T19:01:02+02:00"})        => {'a' => Time.utc(2009, 8, 10, 17, 1, 2)},
-    %({"a": "2009-08-10T19:01:02-05:00"})        => {'a' => Time.utc(2009, 8, 11, 00, 1, 2)},
-    # needs to be *exact*
-    %({"a": " 2007-01-01 01:12:34 Z "})          => {'a' => " 2007-01-01 01:12:34 Z "},
-    %({"a": "2007-01-01 : it's your birthday"})  => {'a' => "2007-01-01 : it's your birthday"},
-    %([])    => [],
-    %({})    => {},
-    %({"a":1})     => {"a" => 1},
-    %({"a": ""})    => {"a" => ""},
-    %({"a":"\\""}) => {"a" => "\""},
-    %({"a": null})  => {"a" => nil},
-    %({"a": true})  => {"a" => true},
-    %({"a": false}) => {"a" => false},
-    %q({"bad":"\\\\","trailing":""}) => {"bad" => "\\", "trailing" => ""},
-    %q({"a": "http:\/\/test.host\/posts\/1"}) => {"a" => "http://test.host/posts/1"},
-    %q({"a": "\u003cunicode\u0020escape\u003e"}) => {"a" => "<unicode escape>"},
-    %q({"a": "\\\\u0020skip double backslashes"}) => {"a" => "\\u0020skip double backslashes"},
-    %q({"a": "\u003cbr /\u003e"}) => {'a' => "<br />"},
-    %q({"b":["\u003ci\u003e","\u003cb\u003e","\u003cu\u003e"]}) => {'b' => ["<i>","<b>","<u>"]},
-    # test combination of dates and escaped or unicode encoded data in arrays
-    %q([{"d":"1970-01-01", "s":"\u0020escape"},{"d":"1970-01-01", "s":"\u0020escape"}]) =>
-      [{'d' => Date.new(1970, 1, 1), 's' => ' escape'},{'d' => Date.new(1970, 1, 1), 's' => ' escape'}],
-    %q([{"d":"1970-01-01","s":"http:\/\/example.com"},{"d":"1970-01-01","s":"http:\/\/example.com"}]) =>
-      [{'d' => Date.new(1970, 1, 1), 's' => 'http://example.com'},
-       {'d' => Date.new(1970, 1, 1), 's' => 'http://example.com'}],
-    # tests escaping of "\n" char with Yaml backend
-    %q({"a":"\n"})  => {"a"=>"\n"},
-    %q({"a":"\u000a"}) => {"a"=>"\n"},
-    %q({"a":"Line1\u000aLine2"}) => {"a"=>"Line1\nLine2"},
-    # prevent json unmarshalling
-    %q({"json_class":"TestJSONDecoding::Foo"}) => {"json_class"=>"TestJSONDecoding::Foo"},
-    # json "fragments" - these are invalid JSON, but ActionPack relies on this
-    %q("a string") => "a string",
-    %q(1.1) => 1.1,
-    %q(1) => 1,
-    %q(-1) => -1,
-    %q(true) => true,
-    %q(false) => false,
-    %q(null) => nil
-  }
-
-  TESTS.each_with_index do |(json, expected), index|
-    test "json decodes #{index}" do
-      prev = ActiveSupport.parse_json_times
-      ActiveSupport.parse_json_times = true
-      silence_warnings do
-        if expected.nil?
-          assert_nil ActiveSupport::JSON.decode(json), "JSON decoding failed for #{json}"
-        else
-          assert_equal expected, ActiveSupport::JSON.decode(json), "JSON decoding failed for #{json}"
-        end
-      end
-      ActiveSupport.parse_json_times = prev
-    end
-  end
-
-  test "json decodes time json with time parsing disabled" do
-    prev = ActiveSupport.parse_json_times
-    ActiveSupport.parse_json_times = false
-    expected = {"a" => "2007-01-01 01:12:34 Z"}
-    assert_equal expected, ActiveSupport::JSON.decode(%({"a": "2007-01-01 01:12:34 Z"}))
-    ActiveSupport.parse_json_times = prev
-  end
-
-  def test_failed_json_decoding
-    assert_raise(ActiveSupport::JSON.parse_error) { ActiveSupport::JSON.decode(%(undefined)) }
-    assert_raise(ActiveSupport::JSON.parse_error) { ActiveSupport::JSON.decode(%({a: 1})) }
-    assert_raise(ActiveSupport::JSON.parse_error) { ActiveSupport::JSON.decode(%({: 1})) }
-    assert_raise(ActiveSupport::JSON.parse_error) { ActiveSupport::JSON.decode(%()) }
-  end
-
-  def test_cannot_pass_unsupported_options
-    assert_raise(ArgumentError) { ActiveSupport::JSON.decode("", create_additions: true) }
-  end
-end
-