backup/EWF
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Replaced git submodule by subtree merged in contrib/library/text/parser/json

Browse Source
This commit is contained in:
Jocelyn Fiat
2012-06-20 09:52:07 +02:00
parent 51b602b42a c873d62efa
commit e8fa284c79
96 changed files with 5929 additions and 4 deletions
Download Patch File Download Diff File Expand all files Collapse all files

24
contrib/library/text/parser/json/test/autotest/test_suite/application.e Normal file
View File

@@ -0,0 +1,24 @@
note
description : "test_suite application root class"
date : "$Date$"
revision : "$Revision$"
class
APPLICATION
inherit
ARGUMENTS
create
make
feature {NONE} -- Initialization
make
-- Run application.
do
--| Add your code here
print ("Hello Eiffel World!%N")
end
end

24
contrib/library/text/parser/json/test/autotest/test_suite/author.e Normal file
View File

@@ -0,0 +1,24 @@
class AUTHOR
create
make
feature {NONE} -- Initialization
make (a_name: STRING_32)
do
set_name (a_name)
end
feature -- Access
name: STRING_32
feature -- Status setting
set_name (a_name: STRING_32)
do
name := a_name
end
end -- class AUTHOR

40
contrib/library/text/parser/json/test/autotest/test_suite/book.e Normal file
View File

@@ -0,0 +1,40 @@
class BOOK
create
make
feature {NONE} -- Initialization
make (a_title: STRING_32; an_author: AUTHOR; an_isbn: STRING_32)
do
set_title (a_title)
set_author (an_author)
set_isbn (an_isbn)
end
feature -- Access
title: STRING_32
isbn: STRING_32
author: AUTHOR
feature -- Status setting
set_title (a_title: STRING_32)
do
title := a_title
end
set_author (an_author: AUTHOR)
do
author := an_author
end
set_isbn (an_isbn: STRING_32)
do
isbn := an_isbn
end
end -- class BOOK

80
contrib/library/text/parser/json/test/autotest/test_suite/book_collection.e Normal file
View File

@@ -0,0 +1,80 @@
class BOOK_COLLECTION
create
make
feature {NONE} -- Initialization
make (a_name: STRING_32)
do
set_name (a_name)
create book_index.make (10)
end
feature -- Access
name: STRING_32
books: LIST [BOOK]
do
from
create {LINKED_LIST [BOOK]} Result.make
book_index.start
until
book_index.after
loop
Result.append (book_index.item_for_iteration)
book_index.forth
end
end
books_by_author (an_author: STRING_32): detachable LIST [BOOK]
do
if book_index.has (an_author) then
Result := book_index @ an_author
else
create {LINKED_LIST [BOOK]} Result.make
end
end
feature -- Status setting
set_name (a_name: STRING_32)
do
name := a_name
end
add_book (a_book: BOOK)
local
l: detachable LIST [BOOK]
do
if book_index.has (a_book.author.name) then
l := book_index.at ( a_book.author.name )
else
create {LINKED_LIST [BOOK]} l.make
book_index.put (l, a_book.author.name)
end
if attached l as la then
la.force (a_book)
end
end
add_books (book_list: like books)
do
from
book_list.start
until
book_list.after
loop
add_book (book_list.item)
book_list.forth
end
end
feature {NONE} -- Implementation
book_index: HASH_TABLE [LIST [BOOK], STRING_32]
end -- class BOOK_COLLECTION

1
contrib/library/text/parser/json/test/autotest/test_suite/fail1.json Normal file
View File

@@ -0,0 +1 @@
"A JSON payload should be an object or array, not a string."

1
contrib/library/text/parser/json/test/autotest/test_suite/fail10.json Normal file
View File

@@ -0,0 +1 @@
{"Extra value after close": true} "misplaced quoted value"

1
contrib/library/text/parser/json/test/autotest/test_suite/fail11.json Normal file
View File

@@ -0,0 +1 @@
{"Illegal expression": 1 + 2}

1
contrib/library/text/parser/json/test/autotest/test_suite/fail12.json Normal file
View File

@@ -0,0 +1 @@
{"Illegal invocation": alert()}

1
contrib/library/text/parser/json/test/autotest/test_suite/fail13.json Normal file
View File

@@ -0,0 +1 @@
{"Numbers cannot have leading zeroes": 013}

1
contrib/library/text/parser/json/test/autotest/test_suite/fail14.json Normal file
View File

@@ -0,0 +1 @@
{"Numbers cannot be hex": 0x14}

1
contrib/library/text/parser/json/test/autotest/test_suite/fail15.json Normal file
View File

@@ -0,0 +1 @@
["Illegal backslash escape: \x15"]

1
contrib/library/text/parser/json/test/autotest/test_suite/fail16.json Normal file
View File

@@ -0,0 +1 @@
[\naked]

1
contrib/library/text/parser/json/test/autotest/test_suite/fail17.json Normal file
View File

@@ -0,0 +1 @@
["Illegal backslash escape: \017"]

1
contrib/library/text/parser/json/test/autotest/test_suite/fail18.json Normal file
View File

@@ -0,0 +1 @@
[[[[[[[[[[[[[[[[[[[["Too deep"]]]]]]]]]]]]]]]]]]]]

1
contrib/library/text/parser/json/test/autotest/test_suite/fail19.json Normal file
View File

@@ -0,0 +1 @@
{"Missing colon" null}

1
contrib/library/text/parser/json/test/autotest/test_suite/fail2.json Normal file
View File

@@ -0,0 +1 @@
["Unclosed array"

1
contrib/library/text/parser/json/test/autotest/test_suite/fail20.json Normal file
View File

@@ -0,0 +1 @@
{"Double colon":: null}

1
contrib/library/text/parser/json/test/autotest/test_suite/fail21.json Normal file
View File

@@ -0,0 +1 @@
{"Comma instead of colon", null}

1
contrib/library/text/parser/json/test/autotest/test_suite/fail22.json Normal file
View File

@@ -0,0 +1 @@
["Colon instead of comma": false]

1
contrib/library/text/parser/json/test/autotest/test_suite/fail23.json Normal file
View File

@@ -0,0 +1 @@
["Bad value", truth]

1
contrib/library/text/parser/json/test/autotest/test_suite/fail24.json Normal file
View File

@@ -0,0 +1 @@
['single quote']

1
contrib/library/text/parser/json/test/autotest/test_suite/fail25.json Normal file
View File

@@ -0,0 +1 @@
[" tab character in string "]

1
contrib/library/text/parser/json/test/autotest/test_suite/fail26.json Normal file
View File

@@ -0,0 +1 @@
["tab\ character\ in\ string\ "]

2
contrib/library/text/parser/json/test/autotest/test_suite/fail27.json Normal file
View File

@@ -0,0 +1,2 @@
["line
break"]

2
contrib/library/text/parser/json/test/autotest/test_suite/fail28.json Normal file
View File

@@ -0,0 +1,2 @@
["line\
break"]

1
contrib/library/text/parser/json/test/autotest/test_suite/fail29.json Normal file
View File

@@ -0,0 +1 @@
[0e]

1
contrib/library/text/parser/json/test/autotest/test_suite/fail3.json Normal file
View File

@@ -0,0 +1 @@
{unquoted_key: "keys must be quoted"}

1
contrib/library/text/parser/json/test/autotest/test_suite/fail30.json Normal file
View File

@@ -0,0 +1 @@
[0e+]

1
contrib/library/text/parser/json/test/autotest/test_suite/fail31.json Normal file
View File

@@ -0,0 +1 @@
[0e+-1]

1
contrib/library/text/parser/json/test/autotest/test_suite/fail32.json Normal file
View File

@@ -0,0 +1 @@
{"Comma instead if closing brace": true,

1
contrib/library/text/parser/json/test/autotest/test_suite/fail33.json Normal file
View File

@@ -0,0 +1 @@
["mismatch"}

1
contrib/library/text/parser/json/test/autotest/test_suite/fail4.json Normal file
View File

@@ -0,0 +1 @@
["extra comma",]

1
contrib/library/text/parser/json/test/autotest/test_suite/fail5.json Normal file
View File

@@ -0,0 +1 @@
["double extra comma",,]

1
contrib/library/text/parser/json/test/autotest/test_suite/fail6.json Normal file
View File

@@ -0,0 +1 @@
[ , "<-- missing value"]

1
contrib/library/text/parser/json/test/autotest/test_suite/fail7.json Normal file
View File

@@ -0,0 +1 @@
["Comma after the close"],

1
contrib/library/text/parser/json/test/autotest/test_suite/fail8.json Normal file
View File

@@ -0,0 +1 @@
["Extra close"]]

1
contrib/library/text/parser/json/test/autotest/test_suite/fail9.json Normal file
View File

@@ -0,0 +1 @@
{"Extra comma": true,}

54
contrib/library/text/parser/json/test/autotest/test_suite/json_author_converter.e Normal file
View File

@@ -0,0 +1,54 @@
note
description: "A JSON converter for AUTHOR"
author: "Paul Cohen"
date: "$Date: 2010-03-08 20:46:59 -0300 (Mon, 08 Mar 2010) $"
revision: "$Revision: 82 $"
file: "$HeadURL: https://svn.origo.ethz.ch/ejson/branches/POC-converters-factory/test/json_author_converter.e $"
class JSON_AUTHOR_CONVERTER
inherit
JSON_CONVERTER
create
make
feature {NONE} -- Initialization
make
local
ucs: STRING_32
do
create ucs.make_from_string ("")
create object.make (ucs)
end
feature -- Access
object: AUTHOR
feature -- Conversion
from_json (j: like to_json): detachable like object
local
ucs: detachable STRING_32
do
ucs ?= json.object (j.item (name_key), Void)
check ucs /= Void end
create Result.make (ucs)
end
to_json (o: like object): JSON_OBJECT
do
create Result.make
Result.put (json.value (o.name), name_key)
end
feature {NONE} -- Implementation
name_key: JSON_STRING
once
create Result.make_json ("name")
end
end -- class JSON_AUTHOR_CONVERTER

79
contrib/library/text/parser/json/test/autotest/test_suite/json_book_collection_converter.e Normal file
View File

@@ -0,0 +1,79 @@
note
description: "A JSON converter for BOOK_COLLECTION"
author: "Paul Cohen"
date: "$Date: 2010-03-08 20:46:59 -0300 (Mon, 08 Mar 2010) $"
revision: "$Revision: 82 $"
file: "$HeadURL: https://svn.origo.ethz.ch/ejson/branches/POC-converters-factory/test/json_book_collection_converter.e $"
class JSON_BOOK_COLLECTION_CONVERTER
inherit
JSON_CONVERTER
create
make
feature {NONE} -- Initialization
make
local
ucs: STRING_32
do
create ucs.make_from_string ("")
create object.make (ucs)
end
feature -- Access
object: BOOK_COLLECTION
feature -- Conversion
from_json (j: like to_json): detachable like object
local
ucs: detachable STRING_32
ll: LINKED_LIST [BOOK]
b: detachable BOOK
ja: detachable JSON_ARRAY
i: INTEGER
do
ucs ?= json.object (j.item (name_key), Void)
check ucs /= Void end
create Result.make (ucs)
ja ?= j.item (books_key)
check ja /= Void end
from
i := 1
create ll.make
until
i > ja.count
loop
b ?= json.object (ja [i], "BOOK")
check b /= Void end
ll.force (b)
i := i + 1
end
check ll /= Void end
Result.add_books (ll)
end
to_json (o: like object): JSON_OBJECT
do
create Result.make
Result.put (json.value (o.name), name_key)
Result.put (json.value (o.books), books_key)
end
feature {NONE} -- Implementation
name_key: JSON_STRING
once
create Result.make_json ("name")
end
books_key: JSON_STRING
once
create Result.make_json ("books")
end
end -- class JSON_BOOK_COLLECTION_CONVERTER

73
contrib/library/text/parser/json/test/autotest/test_suite/json_book_converter.e Normal file
View File

@@ -0,0 +1,73 @@
note
description: "A JSON converter for BOOK"
author: "Paul Cohen"
date: "$Date: 2010-03-08 20:46:59 -0300 (Mon, 08 Mar 2010) $"
revision: "$Revision: 82 $"
file: "$HeadURL: https://svn.origo.ethz.ch/ejson/branches/POC-converters-factory/test/json_book_converter.e $"
class JSON_BOOK_CONVERTER
inherit
JSON_CONVERTER
create
make
feature {NONE} -- Initialization
make
local
ucs: STRING_32
a: AUTHOR
do
create ucs.make_from_string ("")
create a.make (ucs)
create object.make (ucs, a, ucs)
end
feature -- Access
object: BOOK
feature -- Conversion
from_json (j: like to_json): detachable like object
local
ucs1, ucs2: detachable STRING_32
a: detachable AUTHOR
do
ucs1 ?= json.object (j.item (title_key), Void)
check ucs1 /= Void end
ucs2 ?= json.object (j.item (isbn_key), Void)
check ucs2 /= Void end
a ?= json.object (j.item (author_key), "AUTHOR")
check a /= Void end
create Result.make (ucs1, a, ucs2)
end
to_json (o: like object): JSON_OBJECT
do
create Result.make
Result.put (json.value (o.title), title_key)
Result.put (json.value (o.isbn), isbn_key)
Result.put (json.value (o.author), author_key)
end
feature {NONE} -- Implementation
title_key: JSON_STRING
once
create Result.make_json ("title")
end
isbn_key: JSON_STRING
once
create Result.make_json ("isbn")
end
author_key: JSON_STRING
once
create Result.make_json ("author")
end
end -- class JSON_BOOK_CONVERTER

11
contrib/library/text/parser/json/test/autotest/test_suite/json_menu_example.txt Normal file
View File

@@ -0,0 +1,11 @@
{"menu": {
"id": "file",
"value": "File",
"popup": {
"menuitem": [
{"value": "New", "onclick": "CreateNewDoc()"},
{"value": "Open", "onclick": "OpenDoc()"},
{"value": "Close", "onclick": "CloseDoc()"}
]
}
}}

58
contrib/library/text/parser/json/test/autotest/test_suite/pass1.json Normal file
View File

@@ -0,0 +1,58 @@
[
"JSON Test Pattern pass1",
{"object with 1 member":["array with 1 element"]},
{},
[],
-42,
true,
false,
null,
{
"integer": 1234567890,
"real": -9876.543210,
"e": 0.123456789e-12,
"E": 1.234567890E+34,
"": 23456789012E66,
"zero": 0,
"one": 1,
"space": " ",
"quote": "\"",
"backslash": "\\",
"controls": "\b\f\n\r\t",
"slash": "/ & \/",
"alpha": "abcdefghijklmnopqrstuvwyz",
"ALPHA": "ABCDEFGHIJKLMNOPQRSTUVWYZ",
"digit": "0123456789",
"0123456789": "digit",
"special": "`1~!@#$%^&*()_+-={':[,]}|;.</>?",
"hex": "\u0123\u4567\u89AB\uCDEF\uabcd\uef4A",
"true": true,
"false": false,
"null": null,
"array":[ ],
"object":{ },
"address": "50 St. James Street",
"url": "http://www.JSON.org/",
"comment": "// /* <!-- --",
"# -- --> */": " ",
" s p a c e d " :[1,2 , 3
,
4 , 5 , 6 ,7 ],"compact":[1,2,3,4,5,6,7],
"jsontext": "{\"object with 1 member\":[\"array with 1 element\"]}",
"quotes": "&#34; \u0022 %22 0x22 034 &#x22;",
"\/\\\"\uCAFE\uBABE\uAB98\uFCDE\ubcda\uef4A\b\f\n\r\t`1~!@#$%^&*()_+-=[]{}|;:',./<>?"
: "A key can be any string"
},
0.5 ,98.6
,
99.44
,
1066,
1e1,
0.1e1,
1e-1,
1e00,2e+00,2e-00
,"rosebud"]

1
contrib/library/text/parser/json/test/autotest/test_suite/pass2.json Normal file
View File

@@ -0,0 +1 @@
[[[[[[[[[[[[[[[[[[["Not too deep"]]]]]]]]]]]]]]]]]]]

6
contrib/library/text/parser/json/test/autotest/test_suite/pass3.json Normal file
View File

@@ -0,0 +1,6 @@
{
"JSON Test Pattern pass3": {
"The outermost value": "must be an object or array.",
"In this test": "It is an object."
}
}

74
contrib/library/text/parser/json/test/autotest/test_suite/test_ds.e Normal file
View File

@@ -0,0 +1,74 @@
class TEST_DS
inherit
SHARED_EJSON
rename default_create as shared_default_create end
EQA_TEST_SET
select default_create end
feature -- Test
test_linked_list_converter
local
jc: JSON_LINKED_LIST_CONVERTER
l: LINKED_LIST [STRING]
l2: detachable LINKED_LIST [detachable ANY]
s: STRING
jv: detachable JSON_VALUE
do
create jc.make
json.add_converter (jc)
create l.make
s := "foo"
l.force (s)
s := "bar"
l.force (s)
jv := json.value (l)
assert ("jv /= Void", jv /= Void)
if attached jv as l_jv then
s := jv.representation
l2 ?= json.object (jv, "LINKED_LIST")
assert ("l2 /= Void", l2 /= Void)
end
end
test_hash_table_converter
local
tc: JSON_HASH_TABLE_CONVERTER
t: HASH_TABLE [STRING, STRING]
t2: detachable HASH_TABLE [ANY, HASHABLE]
s: STRING
ucs_key, ucs_value: detachable STRING_32
jv: detachable JSON_VALUE
do
create tc.make
json.add_converter (tc)
create t.make (2)
t.put ("foo", "1")
t.put ("bar", "2")
jv := json.value (t)
assert ("jv /= Void", jv /= Void)
if attached jv as l_jv then
s := l_jv.representation
t2 ?= json.object (l_jv, "HASH_TABLE")
assert ("t2 /= Void", t2 /= Void)
end
create ucs_key.make_from_string ("1")
if attached t2 as l_t2 then
ucs_value ?= t2 @ ucs_key
assert ("ucs_value /= Void", ucs_value /= Void)
if attached ucs_value as l_ucs_value then
assert ("ucs_value.string.is_equal (%"foo%")", l_ucs_value.string.is_equal ("foo"))
end
create ucs_key.make_from_string ("2")
ucs_value ?= t2 @ ucs_key
assert ("ucs_value /= Void", ucs_value /= Void)
if attached ucs_value as l_ucs_value then
assert ("ucs_value.string.is_equal (%"bar%")", l_ucs_value.string.is_equal ("bar"))
end
end
end
end -- class TEST_DS

822
contrib/library/text/parser/json/test/autotest/test_suite/test_json_core.e Normal file
View File

@@ -0,0 +1,822 @@
class TEST_JSON_CORE
inherit
SHARED_EJSON
rename default_create as shared_default_create end
EQA_TEST_SET
select default_create end
feature -- Test
test_json_number_and_integer
local
i: INTEGER
jn: JSON_NUMBER
jrep: STRING
parser: JSON_PARSER
do
i := 42
-- Eiffel value -> JSON value -> JSON representation
create jn.make_integer (i)
assert ("jn.representation.same_string (%"42%")", jn.representation.same_string ("42"))
-- Eiffel value -> JSON value -> JSON representation with factory
if attached {JSON_NUMBER} json.value (i) as l_jn then
assert ("l_jn.representation.same_string (%"42%")", jn.representation.same_string ("42"))
else
assert ("json.value (i) is a JSON_NUMBER", False)
end
-- JSON representation-> JSON value -> Eiffel value
-- Note: The JSON_FACTORY will return the smallest INTEGER_* object
-- that can represent the value of the JSON number, in this case
-- we know it is INTEGER_8 since the value is 42
jrep := "42"
create parser.make_parser (jrep)
if attached {JSON_NUMBER} parser.parse as l_jn then
if attached {INTEGER_8} json.object (jn, Void) as l_i8 then
assert ("l_i8 = 42", l_i8 = 42)
else
assert ("json.object (jn, Void) is a INTEGER_8", False)
end
else
assert ("parser.parse is a JSON_NUMBER", False)
end
end
test_json_number_and_integer_8
local
i8: INTEGER_8
jn: JSON_NUMBER
jrep: STRING
parser: JSON_PARSER
do
i8 := 42
-- Eiffel value -> JSON value -> JSON representation
create jn.make_integer (i8)
assert ("jn.representation.same_string (%"42%")", jn.representation.same_string ("42"))
-- Eiffel value -> JSON value -> JSON representation with factory
if attached {JSON_NUMBER} json.value (i8) as l_jn then
assert ("l_jn.representation.same_string (%"42%")", jn.representation.same_string ("42"))
else
assert ("json.value (i8) is a JSON_NUMBER", False)
end
-- JSON representation -> JSON value -> Eiffel value
-- Note: The JSON_FACTORY will return the smallest INTEGER_* object
-- that can represent the value of the JSON number, in this case
-- we know it is INTEGER_8 since the value is 42
jrep := "42"
create parser.make_parser (jrep)
if attached {JSON_NUMBER} parser.parse as l_jn then
if attached {INTEGER_8} json.object (jn, Void) as l_i8 then
assert ("l_i8 = 42", l_i8 = 42)
else
assert ("json.object (jn, Void) is a INTEGER_8", False)
end
else
assert ("parser.parse is a JSON_NUMBER", False)
end
end
test_json_number_and_integer_16
local
i16: INTEGER_16
jn: JSON_NUMBER
jrep: STRING
parser: JSON_PARSER
do
i16 := 300
-- Eiffel value -> JSON value -> JSON representation
create jn.make_integer (i16)
assert ("jn.representation.same_string (%"300%")", jn.representation.same_string ("300"))
-- Eiffel value -> JSON with factory
if attached {JSON_NUMBER} json.value (i16) as l_jn then
assert ("l_jn.representation.same_string (%"300%")", l_jn.representation.same_string ("300"))
else
assert ("json.value (i16) is a JSON_NUMBER", False)
end
-- JSON representation -> JSON value -> Eiffel value
-- Note: The JSON_FACTORY will return the smallest INTEGER_* object
-- that can represent the value of the JSON number, in this case
-- we know it is INTEGER_16 since the value is 300
jrep := "300"
create parser.make_parser (jrep)
if attached {JSON_NUMBER} parser.parse as l_jn then
if attached {INTEGER_16} json.object (jn, Void) as l_i16 then
assert ("l_i16 = 300", l_i16 = 300)
else
assert ("json.object (jn, Void) is a INTEGER_16", False)
end
else
assert ("parser.parse is a JSON_NUMBER", False)
end
end
test_json_number_and_integer_32
local
i32: INTEGER_32
jn: JSON_NUMBER
jrep: STRING
parser: JSON_PARSER
do
i32 := 100000
-- Eiffel value -> JSON representation -> JSON value
create jn.make_integer (i32)
assert ("jn.representation.same_string (%"100000%")", jn.representation.same_string ("100000"))
-- Eiffel value -> JSON representation -> JSON value with factory
if attached {JSON_NUMBER} json.value (i32) as l_jn then
assert ("l_jn.representation.same_string (%"100000%")", l_jn.representation.same_string ("100000"))
else
assert ("json.value (i32) is a JSON_NUMBER", False)
end
-- JSON representation -> JSON value -> Eiffel value
-- Note: The JSON_FACTORY will return the smallest INTEGER_* object
-- that can represent the value of the JSON number, in this case
-- we know it is INTEGER_32 since the value is 100000
jrep := "100000"
create parser.make_parser (jrep)
if attached {JSON_NUMBER} parser.parse as l_jn then
if attached {INTEGER_32} json.object (jn, Void) as l_i32 then
assert ("l_i32 = 100000", l_i32 = 100000)
else
assert ("json.object (jn, Void) is a INTEGER_32", False)
end
else
assert ("parser.parse is a JSON_NUMBER", False)
end
end
test_json_number_and_integer_64
local
i64: INTEGER_64
jn: JSON_NUMBER
jrep: STRING
parser: JSON_PARSER
do
i64 := 42949672960
-- Eiffel value -> JSON value -> JSON representation
create jn.make_integer (i64)
assert ("jn.representation.same_string (%"42949672960%")", jn.representation.same_string ("42949672960"))
-- Eiffel value -> JSON value -> JSON representation with factory
if attached {JSON_NUMBER} json.value (i64) as l_jn then
assert ("l_jn.representation.same_string (%"42949672960%")", l_jn.representation.same_string ("42949672960"))
else
assert ("json.value (i64) is a JSON_NUMBER", False)
end
-- JSON representation -> JSON value -> Eiffel value
-- Note: The JSON_FACTORY will return the smallest INTEGER_* object
-- that can represent the value of the JSON number, in this case
-- we know it is INTEGER_32 since the value is 42949672960
jrep := "42949672960"
create parser.make_parser (jrep)
if attached {JSON_NUMBER} parser.parse as l_jn then
if attached {INTEGER_64} json.object (jn, Void) as l_i64 then
assert ("l_i64 = 42949672960", l_i64 = 42949672960)
else
assert ("json.object (jn, Void) is a INTEGER_64", False)
end
else
assert ("parser.parse is a JSON_NUMBER", False)
end
end
test_json_number_and_natural_8
local
n8: NATURAL_8
jn: JSON_NUMBER
jrep: STRING
parser: JSON_PARSER
do
n8 := 200
-- Eiffel value -> JSON value -> JSON representation
create jn.make_natural (n8)
assert ("jn.representation.same_string (%"200%")", jn.representation.same_string ("200"))
-- Eiffel value -> JSON value -> JSON representation with factory
if attached {JSON_NUMBER} json.value (n8) as l_jn then
assert ("l_jn.representation.same_string (%"200%")", l_jn.representation.same_string ("200"))
else
assert ("json.value (n8) is a JSON_NUMBER}", False)
end
-- JSON representation -> JSON value -> Eiffel value
-- Note: The JSON_FACTORY will return the smallest INTEGER_* object
-- that can represent the value of the JSON number, in this case
-- we know it is INTEGER_16 since the value is 200
jrep := "200"
create parser.make_parser (jrep)
if attached {JSON_NUMBER} parser.parse as l_jn then
if attached {INTEGER_16} json.object (jn, Void) as i16 then
assert ("i16 = 200", i16 = 200)
else
assert ("json.object (jn, Void) is an INTEGER_16", False)
end
else
assert ("parser.parse is a JSON_NUMBER", False)
end
end
test_json_number_and_natural_16
local
n16: NATURAL_16
jn: JSON_NUMBER
jrep: STRING
parser: JSON_PARSER
do
n16 := 32768
-- Eiffel value -> JSON value -> JSON representation
create jn.make_natural (n16)
assert ("jn.representation.same_string (%"32768%")", jn.representation.same_string ("32768"))
-- Eiffel value -> JSON value -> JSON representation with factory
if attached {JSON_NUMBER} json.value (n16) as l_jn then
assert ("l_jn.representation.same_string (%"32768%")", l_jn.representation.same_string ("32768"))
else
assert ("json.value (n16) is a JSON_NUMBER", False)
end
-- JSON representation -> JSON value -> Eiffel value
-- Note: The JSON_FACTORY will return the smallest INTEGER_* object
-- that can represent the value of the JSON number, in this case
-- we know it is INTEGER_32 since the value is 32768
jrep := "32768"
create parser.make_parser (jrep)
if attached {JSON_NUMBER} parser.parse as l_jn then
if attached {INTEGER_32} json.object (jn, Void) as i32 then
assert ("i32 = 32768", i32 = 32768)
else
assert ("json.object (jn, Void) is a INTEGER_32", False)
end
else
assert ("parser.parse is a JSON_NUMBER", False)
end
end
test_json_number_and_natural_32
local
n32: NATURAL_32
jn: JSON_NUMBER
jrep: STRING
parser: JSON_PARSER
do
n32 := 2147483648
-- Eiffel value -> JSON value -> JSON representation
create jn.make_natural (n32)
assert ("jn.representation.same_string (%"2147483648%")", jn.representation.same_string ("2147483648"))
-- Eiffel value -> JSON value -> JSON representation with factory
if attached json.value (n32) as l_jn then
assert ("l_jn.representation.same_string (%"2147483648%")", l_jn.representation.same_string ("2147483648"))
else
assert ("json.value (n32) is a JSON_NUMBER", False)
end
-- JSON representation -> JSON value -> Eiffel value
-- Note: The JSON_FACTORY will return the smallest INTEGER_* object
-- that can represent the value of the JSON number, in this case
-- we know it is INTEGER_64 since the value is 2147483648
jrep := "2147483648"
create parser.make_parser (jrep)
if attached {JSON_NUMBER} parser.parse as l_jn then
if attached {INTEGER_64} json.object (jn, Void) as i64 then
assert ("i64 = 2147483648", i64 = 2147483648)
else
assert ("json.object (jn, Void) is a INTEGER_64", False)
end
else
assert ("parser.parse is a JSON_NUMBER", False)
end
end
test_json_number_and_large_integers
local
jrep: STRING
n64: NATURAL_64
jn: JSON_NUMBER
parser: JSON_PARSER
do
n64 := 9223372036854775808
-- Eiffel value -> JSON value -> JSON representation
create jn.make_natural (n64)
assert ("jn.representation.same_string (%"9223372036854775808%")", jn.representation.same_string ("9223372036854775808"))
-- Eiffel value -> JSON value -> JSON representation with factory
if attached {JSON_NUMBER} json.value (n64) as l_jn then
assert ("l_jn.representation.same_string (%"9223372036854775808%")", l_jn.representation.same_string ("9223372036854775808"))
else
assert ("json.value (n64) is a JSON_NUMBER", False)
end
-- JSON representation -> JSON value -> Eiffel value
-- Note: The JSON_FACTORY will return the smallest INTEGER_* object
-- that can represent the value of the JSON number, in this case
-- we know it is INTEGER_32 since the value is 42949672960
jrep := "9223372036854775808" -- 1 higher than largest positive number that can be represented by INTEGER 64
create parser.make_parser (jrep)
if attached {JSON_NUMBER} parser.parse as l_jn then
if attached {NATURAL_64} json.object (jn, Void) as l_n64 then
assert ("l_n64 = 9223372036854775808", l_n64 = 9223372036854775808)
else
assert ("json.object (jn, Void) is a NATURAL_64", False)
end
else
assert ("parser.parse is a JSON_NUMBER", False)
end
end
test_json_number_and_eiffel_real
local
r: REAL
jn: JSON_NUMBER
jrep: STRING
parser: JSON_PARSER
do
r := 3.14
-- Eiffel value -> JSON value -> JSON representation
create jn.make_real (r)
assert ("jn.representation.same_string (%"3.1400001049041748%")", jn.representation.same_string ("3.1400001049041748"))
-- Eiffel value -> JSON value -> JSON representation with factory
if attached {JSON_NUMBER} json.value (r) as l_jn then
assert ("l_jn.representation.same_string (%"3.1400001049041748%")", l_jn.representation.same_string ("3.1400001049041748"))
else
assert ("json.value (r) is a JSON_NUMBER", False)
end
-- JSON representation -> JSON value -> Eiffel value
-- Note: The JSON_FACTORY will always return a REAL_64 if the value
-- of the JSON number is a floating point number
jrep := "3.14"
create parser.make_parser (jrep)
if attached {JSON_NUMBER} parser.parse as l_jn then
if attached {REAL_64} json.object (jn, Void) as r64 then
assert ("3.14 <= r64 and r64 <= 3.141", 3.14 <= r64 and r64 <= 3.141)
else
assert ("json.object (jn, Void) is a REAL_64", False)
end
else
assert ("parser.parse is a JSON_NUMBER", False)
end
end
test_json_number_and_eiffel_real_32
local
r32: REAL_32
jn: JSON_NUMBER
jrep: STRING
parser: JSON_PARSER
do
r32 := 3.14
-- Eiffel value -> JSON value -> JSON representation
create jn.make_real (r32)
assert ("jn.representation.same_string (%"3.1400001049041748%")", jn.representation.same_string ("3.1400001049041748"))
-- Eiffel value -> JSON value -> JSON representation with factory
if attached {JSON_NUMBER} json.value (r32) as l_jn then
assert ("l_jn.representation.same_string (%"3.1400001049041748%")", l_jn.representation.same_string ("3.1400001049041748"))
else
assert ("json.value (r32) is a JSON_NUMBER", False)
end
-- JSON representation -> JSON value -> Eiffel value
jrep := "3.1400001049041748"
create parser.make_parser (jrep)
if attached {JSON_NUMBER} parser.parse as l_jn then
if attached {REAL_64} json.object (l_jn, Void) as r64 then
assert ("r64 = 3.1400001049041748", r64 = 3.1400001049041748)
else
assert ("json.object (l_jn, Void) is a REAL_64", False)
end
else
assert ("parser.parse is a JSON_NUMBER", False)
end
end
test_json_number_and_eiffel_real_64
local
r64: REAL_64
jn: JSON_NUMBER
jrep: STRING
parser: JSON_PARSER
do
r64 := 3.1415926535897931
-- Eiffel value -> JSON value -> JSON representation
create jn.make_real (r64)
assert ("jn.representation.same_string (%"3.1415926535897931%")", jn.representation.same_string ("3.1415926535897931"))
-- Eiffel value -> JSON value -> JSON representation with factory
if attached {JSON_NUMBER} json.value (r64) as l_jn then
assert ("l_jn.representation.same_string (%"3.1415926535897931%")", l_jn.representation.same_string ("3.1415926535897931"))
else
assert ("json.value (r64) is a JSON_NUMBER", False)
end
-- JSON representation -> JSON value -> Eiffel value
jrep := "3.1415926535897931"
create parser.make_parser (jrep)
if attached {JSON_NUMBER} parser.parse as l_jn then
if attached {REAL_64} json.object (jn, Void) as l_r64 then
assert ("l_r64 = 3.1415926535897931", l_r64 = 3.1415926535897931)
else
assert ("json.object (jn, Void) is a REAL_64", False)
end
else
assert ("parser.parse is a JSON_NUMBER", False)
end
end
test_json_boolean
local
parser: JSON_PARSER
jb: JSON_BOOLEAN
b: BOOLEAN
do
-- Eiffel value -> JSON value -> JSON representation
b := True
create jb.make_boolean (b)
assert ("jb.representation.is_equal (%"true%")", jb.representation.is_equal ("true"))
-- Eiffel value -> JSON value -> JSON representation with factory
if attached {JSON_BOOLEAN} json.value (b) as l_jb then
assert ("l_jb.representation.same_string (%"true%")", l_jb.representation.same_string ("true"))
else
assert ("l_jb /= Void", False)
end
-- JSON representation -> JSON value -> Eiffel value
create parser.make_parser ("true")
if attached {JSON_BOOLEAN} parser.parse as l_jb then
if attached {BOOLEAN} json.object (l_jb, Void) as l_b then
assert ("l_b = True", l_b = True)
else
assert ("json.object (l_jb, Void) is BOOLEAN", False)
end
else
assert ("parser.parse is a JSON_BOOLEAN", False)
end
-- Eiffel value -> JSON value -> JSON representation
b := False
create jb.make_boolean (b)
assert ("jb.representation.same_string (%"false%")", jb.representation.same_string ("false"))
-- Eiffel value -> JSON value -> JSON representation with factory
if attached {JSON_BOOLEAN} json.value (b) as l_jb then
assert ("l_jb.representation.same_string (%"false%")", l_jb.representation.same_string ("false"))
else
assert ("json.value (b) is a JSON_BOOLEAN", False)
end
-- JSON representation -> JSON value -> Eiffel value
create parser.make_parser ("false")
if attached {JSON_BOOLEAN} parser.parse as l_jb then
if attached {BOOLEAN} json.object (l_jb, Void) as l_b then
assert ("l_b = False", l_b = False)
else
assert ("json.object (l_jb, Void) is a BOOLEAN", False)
end
else
assert ("parser.parse is a JSON_BOOLEAN", False)
end
end
test_json_null
local
a: detachable ANY
dummy_object: STRING
jn: detachable JSON_NULL
jrep: STRING
parser: JSON_PARSER
do
-- Eiffel value -> JSON value -> JSON representation
create jn
assert ("jn /= Void", jn /= Void)
assert ("jn.representation.is_equal (%"%"null%"%")", jn.representation.is_equal ("null"))
-- Eiffel value -> JSON value -> JSON representation with factory
jn ?= json.value (Void)
assert ("jn /= Void", jn /= Void)
if attached jn as l_jn then
assert ("jn.representation.is_equal (%"null%")", l_jn.representation.is_equal ("null"))
end
-- JSON representation -> JSON value -> Eiffel value
jrep := "null"
create parser.make_parser (jrep)
jn := Void
jn ?= parser.parse
assert ("jn /= Void", jn /= Void)
create dummy_object.make_empty
a := dummy_object
a ?= json.object (jn, Void)
assert ("a = Void", a = Void)
end
test_json_string_and_character
local
c: CHARACTER
js: detachable JSON_STRING
jrep: STRING
parser: JSON_PARSER
do
c := 'a'
-- Eiffel value -> JSON value -> JSON representation
create js.make_json (c.out)
assert ("js /= Void", js /= Void)
assert ("js.representation.is_equal (%"%"a%"%")", js.representation.is_equal ("%"a%""))
-- Eiffel value -> JSON value -> JSON representation with factory
js ?= json.value (c)
assert ("js /= Void", js /= Void)
if attached js as l_js then
assert ("js.representation.is_equal (%"%"a%"%")", l_js.representation.is_equal ("%"a%""))
end
-- JSON representation -> JSON value -> Eiffel value
jrep := "%"a%""
create parser.make_parser (jrep)
js := Void
js ?= parser.parse
assert ("js /= Void", js /= Void)
if attached {STRING_32} json.object (js, Void) as ucs then
assert ("ucs.string.is_equal (%"a%")", ucs.string.is_equal ("a"))
end
end
test_json_string_and_string
local
s: STRING
js: detachable JSON_STRING
jrep: STRING
parser: JSON_PARSER
do
s := "foobar"
-- Eiffel value -> JSON value -> JSON representation
create js.make_json (s)
assert ("js /= Void", js /= Void)
assert ("js.representation.is_equal (%"%"foobar%"%")", js.representation.is_equal ("%"foobar%""))
-- Eiffel value -> JSON value -> JSON representation with factory
js ?= json.value (s)
assert ("js /= Void", js /= Void)
if attached js as l_js then
assert ("js.representation.is_equal (%"%"foobar%"%")", js.representation.is_equal ("%"foobar%""))
end
-- JSON representation -> JSON value -> Eiffel value
jrep := "%"foobar%""
create parser.make_parser (jrep)
js := Void
js ?= parser.parse
assert ("js /= Void", js /= Void)
if attached {STRING_32} json.object (js, Void) as l_ucs then
assert ("ucs.string.is_equal (%"foobar%")", l_ucs.string.is_equal ("foobar"))
end
end
test_json_string_and_uc_string
local
js: detachable JSON_STRING
ucs: detachable STRING_32
jrep: STRING
parser: JSON_PARSER
do
create ucs.make_from_string ("foobar")
-- Eiffel value -> JSON value -> JSON representation
create js.make_json (ucs)
assert ("js /= Void", js /= Void)
assert ("js.representation.is_equal (%"%"foobar%"%")", js.representation.is_equal ("%"foobar%""))
-- Eiffel value -> JSON value -> JSON representation with factory
js ?= json.value (ucs)
assert ("js /= Void", js /= Void)
if attached js as l_js then
assert ("js.representation.is_equal (%"%"foobar%"%")", l_js.representation.is_equal ("%"foobar%""))
end
-- JSON representation -> JSON value -> Eiffel value
jrep := "%"foobar%""
create parser.make_parser (jrep)
js := Void
js ?= parser.parse
assert ("js /= Void", js /= Void)
ucs := Void
ucs ?= json.object (js, Void)
if attached ucs as l_ucs then
assert ("ucs.string.is_equal (%"foobar%")", l_ucs.string.is_equal ("foobar"))
end
end
test_json_string_and_special_characters
local
js: detachable JSON_STRING
s: detachable STRING_8
ucs: detachable STRING_32
jrep: STRING
parser: JSON_PARSER
do
create s.make_from_string ("foo\bar")
create js.make_json (s)
assert ("js.representation.same_string (%"%"foo\\bar%"%")", js.representation.same_string ("%"foo\\bar%""))
-- Eiffel value -> JSON value -> JSON representation with factory
js ?= json.value (s)
assert ("js /= Void", js /= Void)
if js /= Void then
assert ("js.representation.is_equal (%"%"foobar%"%")", js.representation.same_string ("%"foo\\bar%""))
end
-- JSON representation -> JSON value -> Eiffel value
jrep := "%"foo\\bar%""
create parser.make_parser (jrep)
js ?= parser.parse
assert ("js /= Void", js /= Void)
ucs ?= json.object (js, Void)
if ucs /= Void then
assert ("ucs.same_string (%"foo\bar%")", ucs.same_string ("foo\bar"))
end
jrep := "%"foo\\bar%""
create parser.make_parser (jrep)
if attached {JSON_STRING} parser.parse as jstring then
assert ("unescaped string %"foo\\bar%" to %"foo\bar%"", jstring.unescaped_string_8.same_string ("foo\bar"))
end
create js.make_json_from_string_32 ({STRING_32}"%/20320/%/22909/")
assert ("escaping unicode string32 %"%%/20320/%%/22909/%" %"\u4F60\u597D%"", js.item.same_string ("\u4F60\u597D"))
jrep := "%"\u4F60\u597D%"" --| Ni hao
create parser.make_parser (jrep)
if attached {JSON_STRING} parser.parse as jstring then
assert ("same unicode string32 %"%%/20320/%%/22909/%"", jstring.unescaped_string_32.same_string ({STRING_32}"%/20320/%/22909/"))
end
end
test_json_array
local
ll: LINKED_LIST [INTEGER_8]
ll2: detachable LINKED_LIST [detachable ANY]
ja: detachable JSON_ARRAY
jn: JSON_NUMBER
jrep: STRING
parser: JSON_PARSER
do
-- Eiffel value -> JSON value -> JSON representation
create ll.make
ll.extend (0)
ll.extend (1)
ll.extend (1)
ll.extend (2)
ll.extend (3)
ll.extend (5)
-- Note: Currently there is no simple way of creating a JSON_ARRAY
-- from an LINKED_LIST.
create ja.make_array
from
ll.start
until
ll.after
loop
create jn.make_integer (ll.item)
ja.add (jn)
ll.forth
end
assert ("ja /= Void", ja /= Void)
assert ("ja.representation.is_equal (%"[0,1,1,2,3,5]%")", ja.representation.is_equal ("[0,1,1,2,3,5]"))
-- Eiffel value -> JSON value -> JSON representation with factory
ja := Void
ja ?= json.value (ll)
assert ("ja /= Void", ja /= Void)
if attached ja as l_ja then
assert ("ja.representation.is_equal (%"[0,1,1,2,3,5]%")", l_ja.representation.is_equal ("[0,1,1,2,3,5]"))
end
-- JSON representation -> JSON value -> Eiffel value
-- Note: The JSON_FACTORY will return the smallest INTEGER_* object
-- that can represent the value of the JSON number, in this case
-- it means we will get an LINKED_LIST [ANY] containing the INTEGER_8
-- values 0, 1, 1, 2, 3, 5
jrep := "[0,1,1,2,3,5]"
create parser.make_parser (jrep)
ja := Void
ja ?= parser.parse
assert ("ja /= Void", ja /= Void)
ll2 ?= json.object (ja, Void)
assert ("ll2 /= Void", ll2 /= Void)
--ll.compare_objects
--ll2.compare_objects
if attached ll2 as l_ll2 then
assert ("ll2.is_equal (ll)", l_ll2.is_equal (ll))
end
end
test_json_object
local
t, t2: detachable HASH_TABLE [detachable ANY, STRING_GENERAL]
i: INTEGER
ucs_key, ucs: STRING_32
a: ARRAY [INTEGER]
jo: detachable JSON_OBJECT
jn: JSON_NUMBER
js_key, js: JSON_STRING
ja: JSON_ARRAY
jrep: STRING
parser: JSON_PARSER
do
-- Eiffel value -> JSON value -> JSON representation
-- Note: Currently there is now way of creating a JSON_OBJECT from
-- a HASH_TABLE, so we do it manually.
-- t = {"name": "foobar", "size": 42, "contents", [0, 1, 1, 2, 3, 5]}
create jo.make
create js_key.make_json ("name")
create js.make_json ("foobar")
jo.put (js, js_key)
create js_key.make_json ("size")
create jn.make_integer (42)
jo.put (jn, js_key)
create js_key.make_json ("contents")
create ja.make_array
create jn.make_integer (0)
ja.add (jn)
create jn.make_integer (1)
ja.add (jn)
create jn.make_integer (1)
ja.add (jn)
create jn.make_integer (2)
ja.add (jn)
create jn.make_integer (3)
ja.add (jn)
create jn.make_integer (5)
ja.add (jn)
jo.put (ja, js_key)
assert ("jo /= Void", jo /= Void)
assert ("jo.representation.is_equal (%"{%"name%":%"foobar%",%"size%":42,%"contents%":[0,1,1,2,3,5]}%")", jo.representation.is_equal ("{%"name%":%"foobar%",%"size%":42,%"contents%":[0,1,1,2,3,5]}"))
-- Eiffel value -> JSON value -> JSON representation with factory
create t.make (3)
create ucs_key.make_from_string ("name")
create ucs.make_from_string ("foobar")
t.put (ucs, ucs_key)
create ucs_key.make_from_string ("size")
i := 42
t.put (i, ucs_key)
create ucs_key.make_from_string ("contents")
a := <<0, 1, 1, 2, 3, 5>>
t.put (a, ucs_key)
jo := Void
jo ?= json.value (t)
assert ("jo /= Void", jo /= Void)
if attached jo as l_jo then
assert ("jo.representation.is_equal (%"{%"name%":%"foobar%",%"size%":42,%"contents%":[0,1,1,2,3,5]}%")", l_jo.representation.is_equal ("{%"name%":%"foobar%",%"size%":42,%"contents%":[0,1,1,2,3,5]}"))
end
-- JSON representation -> JSON value -> Eiffel value -> JSON value -> JSON representation
jrep := "{%"name%":%"foobar%",%"size%":42,%"contents%":[0,1,1,2,3,5]}"
create parser.make_parser (jrep)
jo := Void
jo ?= parser.parse
assert ("jo /= Void", jo /= Void)
t2 ?= json.object (jo, Void)
assert ("t2 /= Void", t2 /= Void)
jo ?= json.value (t2)
assert ("jo /= Void", jo /= Void)
if attached jo as l_jo then
assert ("jrep.is_equal (jo.representation)", jrep.is_equal (jo.representation))
end
end
test_json_failed_json_conversion
-- Test converting an Eiffel object to JSON that is based on a class
-- for which no JSON converter has been registered.
local
gv: OPERATING_ENVIRONMENT
jv: detachable JSON_VALUE
exception: BOOLEAN
do
if not exception then
create gv
jv := json.value (gv)
else
assert ("exceptions.is_developer_exception", json.is_developer_exception)
-- assert ("exceptions.is_developer_exception_of_name", json.is_developer_exception_of_name ("eJSON exception: Failed to convert Eiffel object to a JSON_VALUE: OPERATING_ENVIRONMENT"))
end
rescue
exception := True
retry
end
test_json_failed_eiffel_conversion
-- Test converting from a JSON value to an Eiffel object based on a
-- class for which no JSON converter has been registered.
local
gv : detachable OPERATING_ENVIRONMENT
jo: JSON_OBJECT
exception: BOOLEAN
do
if not exception then
create jo.make
gv ?= json.object (jo, "OPERATING_ENVIRONMENT")
else
assert ("exceptions.is_developer_exception", json.is_developer_exception)
-- assert ("exceptions.is_developer_exception_of_name", json.is_developer_exception_of_name ("eJSON exception: Failed to convert JSON_VALUE to an Eiffel object: JSON_OBJECT -> OPERATING_ENVIRONMENT"))
end
rescue
exception := True
retry
end
end -- class TEST_JSON_CORE

42
contrib/library/text/parser/json/test/autotest/test_suite/test_json_custom_classes.e Normal file
View File

@@ -0,0 +1,42 @@
class TEST_JSON_CUSTOM_CLASSES
inherit
SHARED_EJSON
rename default_create as shared_default_create end
EQA_TEST_SET
select default_create end
feature -- Test
test_custom_classes
local
bc: detachable BOOK_COLLECTION
jbc: JSON_BOOK_CONVERTER
jbcc: JSON_BOOK_COLLECTION_CONVERTER
jac: JSON_AUTHOR_CONVERTER
jo: detachable JSON_OBJECT
parser: JSON_PARSER
jrep: STRING
do
create jbc.make
json.add_converter (jbc)
create jbcc.make
json.add_converter (jbcc)
create jac.make
json.add_converter (jac)
jrep := "{%"name%":%"Test collection%",%"books%":[{%"title%":%"eJSON: The Definitive Guide%",%"isbn%":%"123123-413243%",%"author%":{%"name%":%"Foo Bar%"}}]}"
create parser.make_parser (jrep)
jo := Void
jo ?= parser.parse
assert ("jo /= Void", jo /= Void)
bc := Void
bc ?= json.object (jo, "BOOK_COLLECTION")
assert ("bc /= Void", bc /= Void)
jo ?= json.value (bc)
assert ("jo /= Void", jo /= Void)
if attached jo as l_jo then
assert ("JSON representation is correct", l_jo.representation.same_string ("{%"name%":%"Test collection%",%"books%":[{%"title%":%"eJSON: The Definitive Guide%",%"isbn%":%"123123-413243%",%"author%":{%"name%":%"Foo Bar%"}}]}"))
end
end
end -- class TEST_JSON_CUSTOM_CLASS

514
contrib/library/text/parser/json/test/autotest/test_suite/test_json_suite.e Normal file
View File

@@ -0,0 +1,514 @@
note
description: "[
Eiffel tests that can be executed by testing tool.
]"
author: "EiffelStudio test wizard"
date: "$Date$"
revision: "$Revision$"
testing: "type/manual"
class
TEST_JSON_SUITE
inherit
EQA_TEST_SET
redefine
on_prepare
end
feature {NONE} -- Events
on_prepare
-- <Precursor>
do
create file_reader
end
feature -- Tests Pass
test_json_pass1
--
local
parse_json: like new_json_parser
do
if attached json_file_from ("pass1.json") as json_file then
parse_json := new_json_parser (json_file)
json_value := parse_json.parse_json
assert ("pass1.json",parse_json.is_parsed = True)
end
end
test_json_pass2
--
local
parse_json: like new_json_parser
do
if attached json_file_from ("pass2.json") as json_file then
parse_json := new_json_parser (json_file)
json_value := parse_json.parse_json
assert ("pass2.json",parse_json.is_parsed = True)
end
end
test_json_pass3
--
local
parse_json: like new_json_parser
do
if attached json_file_from ("pass3.json") as json_file then
parse_json := new_json_parser (json_file)
json_value := parse_json.parse_json
assert ("pass3.json",parse_json.is_parsed = True)
end
end
feature -- Tests Failures
test_json_fail1
--
local
parse_json: like new_json_parser
do
if attached json_file_from ("fail1.json") as json_file then
parse_json := new_json_parser (json_file)
json_value := parse_json.parse_json
assert ("fail1.json",parse_json.is_parsed = False)
end
end
test_json_fail2
--
local
parse_json: like new_json_parser
do
if attached json_file_from ("fail2.json") as json_file then
parse_json := new_json_parser (json_file)
json_value := parse_json.parse_json
assert ("fail2.json",parse_json.is_parsed = False)
end
end
test_json_fail3
--
local
parse_json: like new_json_parser
do
if attached json_file_from ("fail3.json") as json_file then
parse_json := new_json_parser (json_file)
json_value := parse_json.parse_json
assert ("fail3.json",parse_json.is_parsed = False)
end
end
test_json_fail4
--
local
parse_json: like new_json_parser
do
if attached json_file_from ("fail4.json") as json_file then
parse_json := new_json_parser (json_file)
json_value := parse_json.parse_json
assert ("fail4.json",parse_json.is_parsed = False)
end
end
test_json_fail5
--
local
parse_json: like new_json_parser
do
if attached json_file_from ("fail5.json") as json_file then
parse_json := new_json_parser (json_file)
json_value := parse_json.parse_json
assert ("fail5.json",parse_json.is_parsed = False)
end
end
test_json_fail6
--
local
parse_json: like new_json_parser
do
if attached json_file_from ("fail6.json") as json_file then
parse_json := new_json_parser (json_file)
json_value := parse_json.parse_json
assert ("fail6.json",parse_json.is_parsed = False )
end
end
test_json_fail7
--
local
parse_json: like new_json_parser
do
if attached json_file_from ("fail7.json") as json_file then
parse_json := new_json_parser (json_file)
json_value := parse_json.parse_json
assert ("fail7.json",parse_json.is_parsed = False)
end
end
test_json_fail8
--
local
parse_json: like new_json_parser
do
if attached json_file_from ("fail8.json") as json_file then
parse_json := new_json_parser (json_file)
json_value := parse_json.parse_json
assert ("fail8.json",parse_json.is_parsed = False )
end
end
test_json_fail9
--
local
parse_json: like new_json_parser
do
if attached json_file_from ("fail9.json") as json_file then
parse_json := new_json_parser (json_file)
json_value := parse_json.parse_json
assert ("fail9.json",parse_json.is_parsed = False)
end
end
test_json_fail10
--
local
parse_json: like new_json_parser
do
if attached json_file_from ("fail10.json") as json_file then
parse_json := new_json_parser (json_file)
json_value := parse_json.parse_json
assert ("fail10.json",parse_json.is_parsed = False)
end
end
test_json_fail11
--
local
parse_json: like new_json_parser
do
if attached json_file_from ("fail11.json") as json_file then
parse_json := new_json_parser (json_file)
json_value := parse_json.parse_json
assert ("fail11.json",parse_json.is_parsed = False)
end
end
test_json_fail12
--
local
parse_json: like new_json_parser
do
if attached json_file_from ("fail12.json") as json_file then
parse_json := new_json_parser (json_file)
json_value := parse_json.parse_json
assert ("fail12.json",parse_json.is_parsed = False)
end
end
test_json_fail13
--
local
parse_json: like new_json_parser
do
if attached json_file_from ("fail13.json") as json_file then
parse_json := new_json_parser (json_file)
json_value := parse_json.parse_json
assert ("fail13.json",parse_json.is_parsed = False)
end
end
test_json_fail14
--
local
parse_json: like new_json_parser
do
if attached json_file_from ("fail14.json") as json_file then
parse_json := new_json_parser (json_file)
json_value := parse_json.parse_json
assert ("fail14.json",parse_json.is_parsed = False)
end
end
test_json_fail15
--
local
parse_json: like new_json_parser
do
if attached json_file_from ("fail15.json") as json_file then
parse_json := new_json_parser (json_file)
json_value := parse_json.parse_json
assert ("fail15.json",parse_json.is_parsed = False)
end
end
test_json_fail16
--
local
parse_json: like new_json_parser
do
if attached json_file_from ("fail16.json") as json_file then
parse_json := new_json_parser (json_file)
json_value := parse_json.parse_json
assert ("fail16.json",parse_json.is_parsed = False)
end
end
test_json_fail17
--
local
parse_json: like new_json_parser
do
if attached json_file_from ("fail17.json") as json_file then
parse_json := new_json_parser (json_file)
json_value := parse_json.parse_json
assert ("fail17.json",parse_json.is_parsed = False)
end
end
test_json_fail18
--
local
parse_json: like new_json_parser
do
if attached json_file_from ("fail18.json") as json_file then
parse_json := new_json_parser (json_file)
json_value := parse_json.parse_json
assert ("fail18.json",parse_json.is_parsed = True)
end
end
test_json_fail19
--
local
parse_json: like new_json_parser
do
if attached json_file_from ("fail19.json") as json_file then
parse_json := new_json_parser (json_file)
json_value := parse_json.parse_json
assert ("fail19.json",parse_json.is_parsed = False)
end
end
test_json_fail20
--
local
parse_json: like new_json_parser
do
if attached json_file_from ("fail20.json") as json_file then
parse_json := new_json_parser (json_file)
json_value := parse_json.parse_json
assert ("fail20.json",parse_json.is_parsed = False)
end
end
test_json_fail21
--
local
parse_json: like new_json_parser
do
if attached json_file_from ("fail21.json") as json_file then
parse_json := new_json_parser (json_file)
json_value := parse_json.parse_json
assert ("fail21.json",parse_json.is_parsed = False)
end
end
test_json_fail22
--
local
parse_json: like new_json_parser
do
if attached json_file_from ("fail22.json") as json_file then
parse_json := new_json_parser (json_file)
json_value := parse_json.parse_json
assert ("fail22.json",parse_json.is_parsed = False)
end
end
test_json_fail23
--
local
parse_json: like new_json_parser
do
if attached json_file_from ("fail23.json") as json_file then
parse_json := new_json_parser (json_file)
json_value := parse_json.parse_json
assert ("fail23.json",parse_json.is_parsed = False)
end
end
test_json_fail24
--
local
parse_json: like new_json_parser
do
if attached json_file_from ("fail24.json") as json_file then
parse_json := new_json_parser (json_file)
json_value := parse_json.parse_json
assert ("fail24.json",parse_json.is_parsed = False)
end
end
test_json_fail25
--
local
parse_json: like new_json_parser
do
if attached json_file_from ("fail25.json") as json_file then
parse_json := new_json_parser (json_file)
json_value := parse_json.parse_json
assert ("fail25.json",parse_json.is_parsed = False)
end
end
test_json_fail26
--
local
parse_json: like new_json_parser
do
if attached json_file_from ("fail26.json") as json_file then
parse_json := new_json_parser (json_file)
json_value := parse_json.parse_json
assert ("fail26.json",parse_json.is_parsed = False)
end
end
test_json_fail27
--
local
parse_json: like new_json_parser
do
if attached json_file_from ("fail27.json") as json_file then
parse_json := new_json_parser (json_file)
json_value := parse_json.parse_json
assert ("fail27.json",parse_json.is_parsed = False)
end
end
test_json_fail28
--
local
parse_json: like new_json_parser
do
if attached json_file_from ("fail28.json") as json_file then
parse_json := new_json_parser (json_file)
json_value := parse_json.parse_json
assert ("fail28.json",parse_json.is_parsed = False)
end
end
test_json_fail29
--
local
parse_json: like new_json_parser
do
if attached json_file_from ("fail29.json") as json_file then
parse_json := new_json_parser (json_file)
json_value := parse_json.parse_json
assert ("fail29.json",parse_json.is_parsed = False )
end
end
test_json_fail30
--
local
parse_json: like new_json_parser
do
if attached json_file_from ("fail30.json") as json_file then
parse_json := new_json_parser (json_file)
json_value := parse_json.parse_json
assert ("fail30.json",parse_json.is_parsed = False)
end
end
test_json_fail31
--
local
parse_json: like new_json_parser
do
if attached json_file_from ("fail31.json") as json_file then
parse_json := new_json_parser (json_file)
json_value := parse_json.parse_json
assert ("fail31.json",parse_json.is_parsed = False)
end
end
test_json_fail32
--
local
parse_json: like new_json_parser
do
if attached json_file_from ("fail32.json") as json_file then
parse_json := new_json_parser (json_file)
json_value := parse_json.parse_json
assert ("fail32.json",parse_json.is_parsed = False)
end
end
test_json_fail33
--
local
parse_json: like new_json_parser
do
if attached json_file_from ("fail33.json") as json_file then
parse_json := new_json_parser (json_file)
json_value := parse_json.parse_json
assert ("fail33.json",parse_json.is_parsed = False)
end
end
feature -- JSON_FROM_FILE
file_reader: JSON_FILE_READER
json_value: detachable JSON_VALUE
json_file_from (fn: STRING): detachable STRING
do
Result := file_reader.read_json_from (test_dir + fn)
assert ("File contains json data", Result /= Void)
end
new_json_parser (a_string: STRING): JSON_PARSER
do
create Result.make_parser (a_string)
end
test_dir: STRING
local
i: INTEGER
do
Result := (create {EXECUTION_ENVIRONMENT}).current_working_directory
Result.append_character ((create {OPERATING_ENVIRONMENT}).directory_separator)
-- The should looks like
-- ..json\test\autotest\test_suite\EIFGENs\test_suite\Testing\execution\TEST_JSON_SUITE.test_json_fail1\..\..\..\..\..\fail1.json
from
i := 5
until
i = 0
loop
Result.append_character ('.')
Result.append_character ('.')
Result.append_character ((create {OPERATING_ENVIRONMENT}).directory_separator)
i := i - 1
end
-- Result := "/home/jvelilla/work/project/Eiffel/ejson_dev/trunk/test/autotest/test_suite/"
end
invariant
file_reader /= Void
end

18
contrib/library/text/parser/json/test/autotest/test_suite/test_suite-safe.ecf Normal file
View File

@@ -0,0 +1,18 @@
<?xml version="1.0" encoding="ISO-8859-1"?>
<system xmlns="http://www.eiffel.com/developers/xml/configuration-1-8-0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.eiffel.com/developers/xml/configuration-1-8-0 http://www.eiffel.com/developers/xml/configuration-1-8-0.xsd" name="test_suite" uuid="EA141B17-6A21-4781-8B5F-E9939BAE968A">
<target name="test_suite">
<root cluster="test_suite" class="APPLICATION" feature="make"/>
<file_rule>
<exclude>/EIFGENs$</exclude>
<exclude>/CVS$</exclude>
<exclude>/.svn$</exclude>
</file_rule>
<option warning="true" is_attached_by_default="true" void_safety="all" syntax="standard">
<assertions precondition="true" postcondition="true" check="true" invariant="true" loop="true" supplier_precondition="true"/>
</option>
<library name="base" location="$ISE_LIBRARY\library\base\base-safe.ecf"/>
<library name="json" location="..\..\..\library\json-safe.ecf"/>
<library name="testing" location="$ISE_LIBRARY\library\testing\testing-safe.ecf"/>
<cluster name="test_suite" location=".\" recursive="true"/>
</target>
</system>

19
contrib/library/text/parser/json/test/autotest/test_suite/test_suite.ecf Normal file
View File

@@ -0,0 +1,19 @@
<?xml version="1.0" encoding="ISO-8859-1"?>
<system xmlns="http://www.eiffel.com/developers/xml/configuration-1-5-0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.eiffel.com/developers/xml/configuration-1-5-0 http://www.eiffel.com/developers/xml/configuration-1-5-0.xsd" name="test_suite" uuid="EA141B17-6A21-4781-8B5F-E9939BAE968A">
<target name="test_suite">
<root cluster="test_suite" class="APPLICATION" feature="make"/>
<file_rule>
<exclude>/EIFGENs$</exclude>
<exclude>/CVS$</exclude>
<exclude>/.svn$</exclude>
</file_rule>
<option warning="true">
<assertions precondition="true" postcondition="true" check="true" invariant="true" loop="true" supplier_precondition="true"/>
</option>
<precompile name="base_pre" location="$ISE_PRECOMP\base.ecf"/>
<library name="base" location="$ISE_LIBRARY\library\base\base.ecf"/>
<library name="json" location="..\..\..\library\json.ecf"/>
<library name="testing" location="$ISE_LIBRARY\library\testing\testing.ecf"/>
<cluster name="test_suite" location=".\" recursive="true"/>
</target>
</system>

24
contrib/library/text/parser/json/test/getest/author.e Normal file
View File

@@ -0,0 +1,24 @@
class AUTHOR
create
make
feature {NONE} -- Initialization
make (a_name: UC_STRING) is
do
set_name (a_name)
end
feature -- Access
name: UC_STRING
feature -- Status setting
set_name (a_name: UC_STRING) is
do
name := a_name
end
end -- class AUTHOR

40
contrib/library/text/parser/json/test/getest/book.e Normal file
View File

@@ -0,0 +1,40 @@
class BOOK
create
make
feature {NONE} -- Initialization
make (a_title: UC_STRING; an_author: AUTHOR; an_isbn: UC_STRING) is
do
set_title (a_title)
set_author (an_author)
set_isbn (an_isbn)
end
feature -- Access
title: UC_STRING
isbn: UC_STRING
author: AUTHOR
feature -- Status setting
set_title (a_title: UC_STRING) is
do
title := a_title
end
set_author (an_author: AUTHOR) is
do
author := an_author
end
set_isbn (an_isbn: UC_STRING) is
do
isbn := an_isbn
end
end -- class BOOK

82
contrib/library/text/parser/json/test/getest/book_collection.e Normal file
View File

@@ -0,0 +1,82 @@
class BOOK_COLLECTION
create
make
feature {NONE} -- Initialization
make (a_name: UC_STRING) is
do
set_name (a_name)
create book_index.make (10)
end
feature -- Access
name: UC_STRING
books: DS_LIST [BOOK] is
local
c: DS_HASH_TABLE_CURSOR [DS_LIST [BOOK], UC_STRING]
do
from
create {DS_LINKED_LIST [BOOK]} Result.make
c := book_index.new_cursor
c.start
until
c.after
loop
Result.append_last (c.item)
c.forth
end
end
books_by_author (an_author: UC_STRING): DS_LIST [BOOK] is
do
if book_index.has (an_author) then
Result := book_index @ an_author
else
create {DS_LINKED_LIST [BOOK]} Result.make
end
end
feature -- Status setting
set_name (a_name: UC_STRING) is
do
name := a_name
end
add_book (a_book: BOOK) is
local
l: DS_LIST [BOOK]
do
if book_index.has (a_book.author.name) then
l := book_index @ a_book.author.name
else
create {DS_LINKED_LIST [BOOK]} l.make
book_index.put (l, a_book.author.name)
end
l.put_last (a_book)
end
add_books (book_list: like books) is
local
c: DS_LIST_CURSOR [BOOK]
do
from
c := book_list.new_cursor
c.start
until
c.after
loop
add_book (c.item)
c.forth
end
end
feature {NONE} -- Implementation
book_index: DS_HASH_TABLE [DS_LIST [BOOK], UC_STRING]
end -- class BOOK_COLLECTION

11
contrib/library/text/parser/json/test/getest/ec_compile.bat Normal file
View File

@@ -0,0 +1,11 @@
echo Compiling ejson_test (finalized)
ecb -finalize -c_compile -config ejson_test.ecf -batch -clean > NUL 2>&1
IF %ERRORLEVEL% EQU -1 goto ERROR
copy EIFGENs\ejson_test\F_code\ejson_test.exe ejson_test.exe
goto EOF
:ERROR
echo Error occurred during ejson_test compilation
goto EOF
:EOF

5
contrib/library/text/parser/json/test/getest/ec_compile.sh Executable file
View File

@@ -0,0 +1,5 @@
#!/bin/bash
echo "ec -finalize -c_compile -config ejson_test.ecf > /dev/null 2>&1"
ec -finalize -c_compile -config ejson_test.ecf > /dev/null 2>&1
cp EIFGENs/ejson_test/F_code/ejson_test .

17
contrib/library/text/parser/json/test/getest/ejson_test-win.cfg Normal file
View File

@@ -0,0 +1,17 @@
-- Gobo test (getest) configuration file for eJSON
test
ejson_test
default
class ("TEST_[A-Z0-9_]*")
feature ("test_[a-z0-9_]*")
prefix ("X")
testgen ("TESTGEN")
compile ("ec_compile.bat")
execute ("ejson_test.exe")
cluster
test_dir: "."
end

17
contrib/library/text/parser/json/test/getest/ejson_test.cfg Normal file
View File

@@ -0,0 +1,17 @@
-- Gobo test (getest) configuration file for eJSON
test
ejson_test
default
class ("TEST_[A-Z0-9_]*")
feature ("test_[a-z0-9_]*")
prefix ("X")
testgen ("TESTGEN")
compile ("./ec_compile.sh")
execute ("./ejson_test")
cluster
test_dir: "."
end

21
contrib/library/text/parser/json/test/getest/ejson_test.ecf Normal file
View File

@@ -0,0 +1,21 @@
<?xml version="1.0" encoding="ISO-8859-1"?>
<system xmlns="http://www.eiffel.com/developers/xml/configuration-1-5-0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.eiffel.com/developers/xml/configuration-1-5-0 http://www.eiffel.com/developers/xml/configuration-1-5-0.xsd" name="ejson_test" uuid="9D4BC920-448B-4F84-9F95-5D47686EBC5E">
<target name="ejson_test">
<root class="EJSON_TEST" feature="make"/>
<file_rule>
<exclude>//.svn</exclude>
<exclude>/cvs$</exclude>
<exclude>/EIFGENs$</exclude>
</file_rule>
<option warning="true" void_safety="none" syntax="obsolete">
<assertions precondition="true" postcondition="true" check="true" invariant="true" loop="true" supplier_precondition="true"/>
</option>
<library name="base" location="$ISE_LIBRARY/library/base/base.ecf"/>
<library name="json" location="../../library/json.ecf"/>
<library name="json_gobo_extension" location="../../library/json_gobo_extension.ecf"/>
<library name="gobo_kernel" location="$ISE_LIBRARY/library/gobo/gobo_kernel.ecf"/>
<library name="gobo_structure" location="$ISE_LIBRARY/library/gobo/gobo_structure.ecf"/>
<library name="gobo_test" location="$ISE_LIBRARY/library/gobo/gobo_test.ecf"/>
<cluster name="tests" location="." recursive="true"/>
</target>
</system>

56
contrib/library/text/parser/json/test/getest/json_author_converter.e Normal file
View File

@@ -0,0 +1,56 @@
indexing
description: "A JSON converter for AUTHOR"
author: "Paul Cohen"
date: "$Date$"
revision: "$Revision$"
file: "$HeadURL: https://svn.origo.ethz.ch/ejson/branches/POC-converters-factory/test/json_author_converter.e $"
class JSON_AUTHOR_CONVERTER
inherit
JSON_CONVERTER
create
make
feature {NONE} -- Initialization
make is
local
ucs: UC_STRING
do
create ucs.make_from_string ("")
create object.make (ucs)
end
feature -- Access
value: JSON_OBJECT
object: AUTHOR
feature -- Conversion
from_json (j: like value): like object is
local
ucs: UC_STRING
do
ucs ?= json.object (j.item (name_key), Void)
check ucs /= Void end
create Result.make (ucs)
end
to_json (o: like object): like value is
do
create Result.make
Result.put (json.value (o.name), name_key)
end
feature {NONE} -- Implementation
name_key: JSON_STRING is
once
create Result.make_json ("name")
end
end -- class JSON_AUTHOR_CONVERTER

81
contrib/library/text/parser/json/test/getest/json_book_collection_converter.e Normal file
View File

@@ -0,0 +1,81 @@
indexing
description: "A JSON converter for BOOK_COLLECTION"
author: "Paul Cohen"
date: "$Date$"
revision: "$Revision$"
file: "$HeadURL: https://svn.origo.ethz.ch/ejson/branches/POC-converters-factory/test/json_book_collection_converter.e $"
class JSON_BOOK_COLLECTION_CONVERTER
inherit
JSON_CONVERTER
create
make
feature {NONE} -- Initialization
make is
local
ucs: UC_STRING
do
create ucs.make_from_string ("")
create object.make (ucs)
end
feature -- Access
value: JSON_OBJECT
object: BOOK_COLLECTION
feature -- Conversion
from_json (j: like value): like object is
local
ucs: UC_STRING
ll: DS_LINKED_LIST [BOOK]
b: BOOK
ja: JSON_ARRAY
i: INTEGER
do
ucs ?= json.object (j.item (name_key), Void)
check ucs /= Void end
create Result.make (ucs)
ja ?= j.item (books_key)
check ja /= Void end
from
i := 1
create ll.make
until
i > ja.count
loop
b ?= json.object (ja [i], "BOOK")
check b /= Void end
ll.put_last (b)
i := i + 1
end
check ll /= Void end
Result.add_books (ll)
end
to_json (o: like object): like value is
do
create Result.make
Result.put (json.value (o.name), name_key)
Result.put (json.value (o.books), books_key)
end
feature {NONE} -- Implementation
name_key: JSON_STRING is
once
create Result.make_json ("name")
end
books_key: JSON_STRING is
once
create Result.make_json ("books")
end
end -- class JSON_BOOK_COLLECTION_CONVERTER

75
contrib/library/text/parser/json/test/getest/json_book_converter.e Normal file
View File

@@ -0,0 +1,75 @@
indexing
description: "A JSON converter for BOOK"
author: "Paul Cohen"
date: "$Date$"
revision: "$Revision$"
file: "$HeadURL: https://svn.origo.ethz.ch/ejson/branches/POC-converters-factory/test/json_book_converter.e $"
class JSON_BOOK_CONVERTER
inherit
JSON_CONVERTER
create
make
feature {NONE} -- Initialization
make is
local
ucs: UC_STRING
a: AUTHOR
do
create ucs.make_from_string ("")
create a.make (ucs)
create object.make (ucs, a, ucs)
end
feature -- Access
value: JSON_OBJECT
object: BOOK
feature -- Conversion
from_json (j: like value): like object is
local
ucs1, ucs2: UC_STRING
a: AUTHOR
do
ucs1 ?= json.object (j.item (title_key), Void)
check ucs1 /= Void end
ucs2 ?= json.object (j.item (isbn_key), Void)
check ucs2 /= Void end
a ?= json.object (j.item (author_key), "AUTHOR")
check a /= Void end
create Result.make (ucs1, a, ucs2)
end
to_json (o: like object): like value is
do
create Result.make
Result.put (json.value (o.title), title_key)
Result.put (json.value (o.isbn), isbn_key)
Result.put (json.value (o.author), author_key)
end
feature {NONE} -- Implementation
title_key: JSON_STRING is
once
create Result.make_json ("title")
end
isbn_key: JSON_STRING is
once
create Result.make_json ("isbn")
end
author_key: JSON_STRING is
once
create Result.make_json ("author")
end
end -- class JSON_BOOK_CONVERTER

10
contrib/library/text/parser/json/test/getest/readme.txt Normal file
View File

@@ -0,0 +1,10 @@
To compile and run the test program do as follows:
1. Make sure you have a compiled version of getest in your PATH.
2. In this dircetory, run the command:
$ getest --verbose --ise ejson_test.cfg
Note: on Windows, you should use ejson_test-win.cfg

71
contrib/library/text/parser/json/test/getest/test_ds.e Normal file
View File

@@ -0,0 +1,71 @@
class TEST_DS
inherit
SHARED_GOBO_EJSON
TS_TEST_CASE
create
make_default
feature {NONE} -- Initialization
make is
-- Create test object.
do
end
feature -- Test
test_ds_linked_list_converter is
local
jc: JSON_DS_LINKED_LIST_CONVERTER
l: DS_LINKED_LIST [STRING]
l2: DS_LINKED_LIST [ANY]
s: STRING
jv: JSON_VALUE
do
create jc.make
json.add_converter (jc)
create l.make
s := "foo"
l.put_last (s)
s := "bar"
l.put_last (s)
jv := json.value (l)
assert ("jv /= Void", jv /= Void)
s := jv.representation
l2 ?= json.object (jv, "DS_LINKED_LIST")
assert ("l2 /= Void", l2 /= Void)
end
test_ds_hash_table_converter is
local
tc: JSON_DS_HASH_TABLE_CONVERTER
t: DS_HASH_TABLE [STRING, STRING]
t2: DS_HASH_TABLE [ANY, HASHABLE]
s: STRING
ucs_key, ucs_value: UC_STRING
jv: JSON_VALUE
do
create tc.make
json.add_converter (tc)
create t.make (2)
t.put ("foo", "1")
t.put ("bar", "2")
jv := json.value (t)
assert ("jv /= Void", jv /= Void)
s := jv.representation
t2 ?= json.object (jv, "DS_HASH_TABLE")
assert ("t2 /= Void", t2 /= Void)
create ucs_key.make_from_string ("1")
ucs_value ?= t2 @ ucs_key
assert ("ucs_value /= Void", ucs_value /= Void)
assert ("ucs_value.string.is_equal (%"foo%")", ucs_value.string.is_equal ("foo"))
create ucs_key.make_from_string ("2")
ucs_value ?= t2 @ ucs_key
assert ("ucs_value /= Void", ucs_value /= Void)
assert ("ucs_value.string.is_equal (%"bar%")", ucs_value.string.is_equal ("bar"))
end
end -- class TEST_DS

703
contrib/library/text/parser/json/test/getest/test_json_core.e Normal file
View File

@@ -0,0 +1,703 @@
class TEST_JSON_CORE
inherit
TS_TEST_CASE
SHARED_EJSON
create
make_default
feature {NONE} -- Initialization
make is
-- Create test object.
do
end
feature -- Test
test_json_number_and_integer is
local
i: INTEGER
i8: INTEGER_8
jn: JSON_NUMBER
jrep: STRING
parser: JSON_PARSER
do
i := 42
-- Eiffel value -> JSON value -> JSON representation
create jn.make_integer (i)
assert ("jn /= Void", jn /= Void)
assert ("jn.representation.is_equal (%"42%")", jn.representation.is_equal ("42"))
-- Eiffel value -> JSON value -> JSON representation with factory
jn := Void
jn ?= json.value (i)
assert ("jn /= Void", jn /= Void)
assert ("jn.representation.is_equal (%"42%")", jn.representation.is_equal ("42"))
-- JSON representation-> JSON value -> Eiffel value
-- Note: The JSON_FACTORY will return the smallest INTEGER_* object
-- that can represent the value of the JSON number, in this case
-- we know it is INTEGER_8 since the value is 42
jrep := "42"
create parser.make_parser (jrep)
jn := Void
jn ?= parser.parse
assert ("jn /= Void", jn /= Void)
i8 := 0
i8 ?= json.object (jn, Void)
assert ("i8 = 42", i8 = 42)
end
test_json_number_and_integer_8 is
local
i8: INTEGER_8
jn: JSON_NUMBER
jrep: STRING
parser: JSON_PARSER
do
i8 := 42
-- Eiffel value -> JSON value -> JSON representation
create jn.make_integer (i8)
assert ("jn /= Void", jn /= Void)
assert ("jn.representation.is_equal (%"42%")", jn.representation.is_equal ("42"))
-- Eiffel value -> JSON value -> JSON representation with factory
jn := Void
jn ?= json.value (i8)
assert ("jn /= Void", jn /= Void)
assert ("jn.representation.is_equal (%"42%")", jn.representation.is_equal ("42"))
-- JSON representation -> JSON value -> Eiffel value
-- Note: The JSON_FACTORY will return the smallest INTEGER_* object
-- that can represent the value of the JSON number, in this case
-- we know it is INTEGER_8 since the value is 42
jrep := "42"
create parser.make_parser (jrep)
jn := Void
jn ?= parser.parse
assert ("jn /= Void", jn /= Void)
i8 := 0
i8 ?= json.object (jn, Void)
assert ("i8 = 42", i8 = 42)
end
test_json_number_and_integer_16 is
local
i16: INTEGER_16
jn: JSON_NUMBER
jrep: STRING
parser: JSON_PARSER
do
i16 := 300
-- Eiffel value -> JSON value -> JSON representation
create jn.make_integer (i16)
assert ("jn /= Void", jn /= Void)
assert ("jn.representation.is_equal (%"300%")", jn.representation.is_equal ("300"))
-- Eiffel value -> JSON with factory
jn := Void
jn ?= json.value (i16)
assert ("jn /= Void", jn /= Void)
assert ("jn.representation.is_equal (%"300%")", jn.representation.is_equal ("300"))
-- JSON representation -> JSON value -> Eiffel value
-- Note: The JSON_FACTORY will return the smallest INTEGER_* object
-- that can represent the value of the JSON number, in this case
-- we know it is INTEGER_16 since the value is 300
jrep := "300"
create parser.make_parser (jrep)
jn := Void
jn ?= parser.parse
assert ("jn /= Void", jn /= Void)
i16 := 0
i16 ?= json.object (jn, Void)
assert ("i16 = 300", i16 = 300)
end
test_json_number_and_integer_32 is
local
i32: INTEGER_32
jn: JSON_NUMBER
jrep: STRING
parser: JSON_PARSER
do
i32 := 100000
-- Eiffel value -> JSON representation -> JSON value
create jn.make_integer (i32)
assert ("jn /= Void", jn /= Void)
assert ("jn.representation.is_equal (%"100000%")", jn.representation.is_equal ("100000"))
-- Eiffel value -> JSON representation -> JSON value with factory
jn := Void
jn ?= json.value (i32)
assert ("jn /= Void", jn /= Void)
assert ("jn.representation.is_equal (%"100000%")", jn.representation.is_equal ("100000"))
-- JSON representation -> JSON value -> Eiffel value
-- Note: The JSON_FACTORY will return the smallest INTEGER_* object
-- that can represent the value of the JSON number, in this case
-- we know it is INTEGER_32 since the value is 100000
jrep := "100000"
create parser.make_parser (jrep)
jn := Void
jn ?= parser.parse
assert ("jn /= Void", jn /= Void)
i32 := 0
i32 ?= json.object (jn, Void)
assert ("i32 = 100000", i32 = 100000)
end
test_json_number_and_integer_64 is
local
i64: INTEGER_64
jn: JSON_NUMBER
jrep: STRING
parser: JSON_PARSER
do
i64 := 42949672960
-- Eiffel value -> JSON value -> JSON representation
create jn.make_integer (i64)
assert ("jn /= Void", jn /= Void)
assert ("jn.representation.is_equal (%"42949672960%")", jn.representation.is_equal ("42949672960"))
-- Eiffel value -> JSON value -> JSON representation with factory
jn := Void
jn ?= json.value (i64)
assert ("jn /= Void", jn /= Void)
assert ("jn.representation.is_equal (%"42949672960%")", jn.representation.is_equal ("42949672960"))
-- JSON representation -> JSON value -> Eiffel value
-- Note: The JSON_FACTORY will return the smallest INTEGER_* object
-- that can represent the value of the JSON number, in this case
-- we know it is INTEGER_32 since the value is 42949672960
jrep := "42949672960"
create parser.make_parser (jrep)
jn := Void
jn ?= parser.parse
assert ("jn /= Void", jn /= Void)
i64 := 0
i64 ?= json.object (jn, Void)
assert ("i64 = 42949672960", i64 = 42949672960)
end
test_json_number_and_natural_8 is
local
n8: NATURAL_8
i16: INTEGER_16
jn: JSON_NUMBER
jrep: STRING
parser: JSON_PARSER
do
n8 := 200
-- Eiffel value -> JSON value -> JSON representation
create jn.make_natural (n8)
assert ("jn /= Void", jn /= Void)
assert ("jn.representation.is_equal (%"200%")", jn.representation.is_equal ("200"))
-- Eiffel value -> JSON value -> JSON representation with factory
jn := Void
jn ?= json.value (n8)
assert ("jn /= Void", jn /= Void)
assert ("jn.representation.is_equal (%"200%")", jn.representation.is_equal ("200"))
-- JSON representation -> JSON value -> Eiffel value
-- Note: The JSON_FACTORY will return the smallest INTEGER_* object
-- that can represent the value of the JSON number, in this case
-- we know it is INTEGER_16 since the value is 200
jrep := "200"
create parser.make_parser (jrep)
jn := Void
jn ?= parser.parse
assert ("jn /= Void", jn /= Void)
i16 := 0
i16 ?= json.object (jn, Void)
assert ("i16 = 200", i16 = 200)
end
test_json_number_and_natural_16 is
local
n16: NATURAL_16
i32: INTEGER_32
jn: JSON_NUMBER
jrep: STRING
parser: JSON_PARSER
do
n16 := 32768
-- Eiffel value -> JSON value -> JSON representation
create jn.make_natural (n16)
assert ("jn /= Void", jn /= Void)
assert ("jn.representation.is_equal (%"32768%")", jn.representation.is_equal ("32768"))
-- Eiffel value -> JSON value -> JSON representation with factory
jn := Void
jn ?= json.value (n16)
assert ("jn /= Void", jn /= Void)
assert ("jn.representation.is_equal (%"32768%")", jn.representation.is_equal ("32768"))
-- JSON representation -> JSON value -> Eiffel value
-- Note: The JSON_FACTORY will return the smallest INTEGER_* object
-- that can represent the value of the JSON number, in this case
-- we know it is INTEGER_32 since the value is 32768
jrep := "32768"
create parser.make_parser (jrep)
jn := Void
jn ?= parser.parse
assert ("jn /= Void", jn /= Void)
i32 := 0
i32 ?= json.object (jn, Void)
assert ("i32 = 32768", i32 = 32768)
end
test_json_number_and_natural_32 is
local
n32: NATURAL_32
i64: INTEGER_64
jn: JSON_NUMBER
jrep: STRING
parser: JSON_PARSER
do
n32 := 2147483648
-- Eiffel value -> JSON value -> JSON representation
create jn.make_natural (n32)
assert ("jn /= Void", jn /= Void)
assert ("jn.representation.is_equal (%"2147483648%")", jn.representation.is_equal ("2147483648"))
-- Eiffel value -> JSON value -> JSON representation with factory
jn := Void
jn ?= json.value (n32)
assert ("jn /= Void", jn /= Void)
assert ("jn.representation.is_equal (%"2147483648%")", jn.representation.is_equal ("2147483648"))
-- JSON representation -> JSON value -> Eiffel value
-- Note: The JSON_FACTORY will return the smallest INTEGER_* object
-- that can represent the value of the JSON number, in this case
-- we know it is INTEGER_64 since the value is 2147483648
jrep := "2147483648"
create parser.make_parser (jrep)
jn := Void
jn ?= parser.parse
assert ("jn /= Void", jn /= Void)
i64 := 0
i64 ?= json.object (jn, Void)
assert ("i64 = 2147483648", i64 = 2147483648)
end
test_json_number_and_large_integers is
local
jrep: STRING
jn: JSON_NUMBER
n64: NATURAL_64
parser: JSON_PARSER
do
n64 := 9223372036854775808
-- Eiffel value -> JSON value -> JSON representation
create jn.make_natural (n64)
assert ("jn /= Void", jn /= Void)
assert ("jn.representation.is_equal (%"9223372036854775808%")", jn.representation.is_equal ("9223372036854775808"))
jn := Void
-- Eiffel value -> JSON value -> JSON representation with factory
jn ?= json.value (n64)
assert ("jn /= Void", jn /= Void)
assert ("jn.representation.is_equal (%"9223372036854775808%")", jn.representation.is_equal ("9223372036854775808"))
-- JSON representation -> JSON value -> Eiffel value
-- Note: The JSON_FACTORY will return the smallest INTEGER_* object
-- that can represent the value of the JSON number, in this case
-- we know it is INTEGER_32 since the value is 42949672960
jrep := "9223372036854775808" -- 1 higher than largest positive number that can be represented by INTEGER 64
create parser.make_parser (jrep)
jn := Void
jn ?= parser.parse
assert ("jn /= Void", jn /= Void)
n64 := 0
n64 ?= json.object (jn, Void)
end
test_json_number_and_eiffel_real is
local
r: REAL
r64: REAL_64
jn: JSON_NUMBER
jrep: STRING
parser: JSON_PARSER
do
r := 3.14
-- Eiffel value -> JSON value -> JSON representation
create jn.make_real (r)
assert ("jn /= Void", jn /= Void)
assert ("jn.representation.is_equal (%"3.1400001049041748%")", jn.representation.is_equal ("3.1400001049041748"))
-- Eiffel value -> JSON value -> JSON representation with factory
jn ?= json.value (r)
assert ("jn /= Void", jn /= Void)
assert ("jn.representation.is_equal (%"3.1400001049041748%")", jn.representation.is_equal ("3.1400001049041748"))
-- JSON representation -> JSON value -> Eiffel value
-- Note: The JSON_FACTORY will always return a REAL_64 if the value
-- of the JSON number is a floating point number
jrep := "3.14"
create parser.make_parser (jrep)
jn := Void
jn ?= parser.parse
assert ("jn /= Void", jn /= Void)
r64 := 0
r64 ?= json.object (jn, Void)
assert ("r64 = 3.1400000000000001", r64 = 3.1400000000000001)
end
test_json_number_and_eiffel_real_32 is
local
r32: REAL_32
r64: REAL_64
jn: JSON_NUMBER
jrep: STRING
parser: JSON_PARSER
do
r32 := 3.14
-- Eiffel value -> JSON value -> JSON representation
create jn.make_real (r32)
assert ("jn /= Void", jn /= Void)
assert ("jn.representation.is_equal (%"3.1400001049041748%")", jn.representation.is_equal ("3.1400001049041748"))
-- Eiffel value -> JSON value -> JSON representation with factory
jn ?= json.value (r32)
assert ("jn /= Void", jn /= Void)
assert ("jn.representation.is_equal (%"3.1400001049041748%")", jn.representation.is_equal ("3.1400001049041748"))
-- JSON representation -> JSON value -> Eiffel value
jrep := "3.1400001049041748"
create parser.make_parser (jrep)
jn ?= parser.parse
assert ("jn /= Void", jn /= Void)
r64 := 0
r64 ?= json.object (jn, Void)
assert ("r64 = 3.1400001049041748", r64 = 3.1400001049041748)
end
test_json_number_and_eiffel_real_64 is
local
r64: REAL_64
jn: JSON_NUMBER
jrep: STRING
parser: JSON_PARSER
do
r64 := 3.1415926535897931
-- Eiffel value -> JSON value -> JSON representation
create jn.make_real (r64)
assert ("jn /= Void", jn /= Void)
assert ("jn.representation.is_equal (%"3.1415926535897931%")", jn.representation.is_equal ("3.1415926535897931"))
-- Eiffel value -> JSON value -> JSON representation with factory
jn ?= json.value (r64)
assert ("jn /= Void", jn /= Void)
assert ("jn.representation.is_equal (%"3.1415926535897931%")", jn.representation.is_equal ("3.1415926535897931"))
-- JSON representation -> JSON value -> Eiffel value
jrep := "3.1415926535897931"
create parser.make_parser (jrep)
jn := Void
jn ?= parser.parse
assert ("jn /= Void", jn /= Void)
r64 := 0
r64 ?= json.object (jn, Void)
assert ("r64 = 3.1415926535897931", r64 = 3.1415926535897931)
end
test_json_boolean is
local
b: BOOLEAN
jb: JSON_BOOLEAN
jrep: STRING
parser: JSON_PARSER
do
b := True
-- Eiffel value -> JSON value -> JSON representation
create jb.make_boolean (b)
assert ("jb /= Void", jb /= Void)
assert ("jb.representation.is_equal (%"true%")", jb.representation.is_equal ("true"))
-- Eiffel value -> JSON value -> JSON representation with factory
jb ?= json.value (b)
assert ("jb /= Void", jb /= Void)
assert ("jb.representation.is_equal (%"true%")", jb.representation.is_equal ("true"))
-- JSON representation -> JSON value -> Eiffel value
jrep := "true"
create parser.make_parser (jrep)
jb := Void
jb ?= parser.parse
assert ("jb /= Void", jb /= Void)
b := False
b ?= json.object (jb, Void)
assert ("b = True", b = True)
b := False
-- Eiffel value -> JSON value -> JSON representation
create jb.make_boolean (b)
assert ("jb /= Void", jb /= Void)
assert ("jb.representation.is_equal (%"false%")", jb.representation.is_equal ("false"))
-- Eiffel value -> JSON value -> JSON representation with factory
jb ?= json.value (b)
assert ("jb /= Void", jb /= Void)
assert ("jb.representation.is_equal (%"false%")", jb.representation.is_equal ("false"))
-- JSON representation -> JSON value -> Eiffel value
jrep := "false"
create parser.make_parser (jrep)
jb := Void
jb ?= parser.parse
assert ("jb /= Void", jb /= Void)
b := True
b ?= json.object (jb, Void)
assert ("b = False", b = False)
end
test_json_null is
local
a: ANY
dummy_object: STRING
jn: JSON_NULL
jrep: STRING
parser: JSON_PARSER
do
-- Eiffel value -> JSON value -> JSON representation
create jn
assert ("jn /= Void", jn /= Void)
assert ("jn.representation.is_equal (%"%"null%"%")", jn.representation.is_equal ("null"))
-- Eiffel value -> JSON value -> JSON representation with factory
jn ?= json.value (Void)
assert ("jn /= Void", jn /= Void)
assert ("jn.representation.is_equal (%"null%")", jn.representation.is_equal ("null"))
-- JSON representation -> JSON value -> Eiffel value
jrep := "null"
create parser.make_parser (jrep)
jn := Void
jn ?= parser.parse
assert ("jn /= Void", jn /= Void)
create dummy_object.make_empty
a := dummy_object
a ?= json.object (jn, Void)
assert ("a = Void", a = Void)
end
test_json_string_and_character is
local
c: CHARACTER
js: JSON_STRING
ucs: UC_STRING
jrep: STRING
parser: JSON_PARSER
do
c := 'a'
-- Eiffel value -> JSON value -> JSON representation
create js.make_json (c.out)
assert ("js /= Void", js /= Void)
assert ("js.representation.is_equal (%"%"a%"%")", js.representation.is_equal ("%"a%""))
-- Eiffel value -> JSON value -> JSON representation with factory
js ?= json.value (c)
assert ("js /= Void", js /= Void)
assert ("js.representation.is_equal (%"%"a%"%")", js.representation.is_equal ("%"a%""))
-- JSON representation -> JSON value -> Eiffel value
jrep := "%"a%""
create parser.make_parser (jrep)
js := Void
js ?= parser.parse
assert ("js /= Void", js /= Void)
ucs ?= json.object (js, Void)
assert ("ucs.string.is_equal (%"a%")", ucs.string.is_equal ("a"))
end
test_json_string_and_string is
local
s: STRING
js: JSON_STRING
ucs: UC_STRING
jrep: STRING
parser: JSON_PARSER
do
s := "foobar"
-- Eiffel value -> JSON value -> JSON representation
create js.make_json (s)
assert ("js /= Void", js /= Void)
assert ("js.representation.is_equal (%"%"foobar%"%")", js.representation.is_equal ("%"foobar%""))
-- Eiffel value -> JSON value -> JSON representation with factory
js ?= json.value (s)
assert ("js /= Void", js /= Void)
assert ("js.representation.is_equal (%"%"foobar%"%")", js.representation.is_equal ("%"foobar%""))
-- JSON representation -> JSON value -> Eiffel value
jrep := "%"foobar%""
create parser.make_parser (jrep)
js := Void
js ?= parser.parse
assert ("js /= Void", js /= Void)
ucs ?= json.object (js, Void)
assert ("ucs.string.is_equal (%"foobar%")", ucs.string.is_equal ("foobar"))
end
test_json_string_and_uc_string is
local
js: JSON_STRING
ucs: UC_STRING
jrep: STRING
parser: JSON_PARSER
do
create ucs.make_from_string ("foobar")
-- Eiffel value -> JSON value -> JSON representation
create js.make_json (ucs)
assert ("js /= Void", js /= Void)
assert ("js.representation.is_equal (%"%"foobar%"%")", js.representation.is_equal ("%"foobar%""))
-- Eiffel value -> JSON value -> JSON representation with factory
js ?= json.value (ucs)
assert ("js /= Void", js /= Void)
assert ("js.representation.is_equal (%"%"foobar%"%")", js.representation.is_equal ("%"foobar%""))
-- JSON representation -> JSON value -> Eiffel value
jrep := "%"foobar%""
create parser.make_parser (jrep)
js := Void
js ?= parser.parse
assert ("js /= Void", js /= Void)
ucs := Void
ucs ?= json.object (js, Void)
assert ("ucs.string.is_equal (%"foobar%")", ucs.string.is_equal ("foobar"))
end
test_json_array is
local
ll: LINKED_LIST [INTEGER_8]
ll2: LINKED_LIST [ANY]
ja: JSON_ARRAY
jn: JSON_NUMBER
jrep: STRING
parser: JSON_PARSER
i, n: INTEGER
do
-- Eiffel value -> JSON value -> JSON representation
create ll.make
ll.extend (0)
ll.extend (1)
ll.extend (1)
ll.extend (2)
ll.extend (3)
ll.extend (5)
-- Note: Currently there is no simple way of creating a JSON_ARRAY
-- from an LINKED_LIST.
create ja.make_array
from
ll.start
until
ll.after
loop
create jn.make_integer (ll.item)
ja.add (jn)
ll.forth
end
assert ("ja /= Void", ja /= Void)
assert ("ja.representation.is_equal (%"[0,1,1,2,3,5]%")", ja.representation.is_equal ("[0,1,1,2,3,5]"))
-- Eiffel value -> JSON value -> JSON representation with factory
ja := Void
ja ?= json.value (ll)
assert ("ja /= Void", ja /= Void)
assert ("ja.representation.is_equal (%"[0,1,1,2,3,5]%")", ja.representation.is_equal ("[0,1,1,2,3,5]"))
-- JSON representation -> JSON value -> Eiffel value
-- Note: The JSON_FACTORY will return the smallest INTEGER_* object
-- that can represent the value of the JSON number, in this case
-- it means we will get an LINKED_LIST [ANY] containing the INTEGER_8
-- values 0, 1, 1, 2, 3, 5
jrep := "[0,1,1,2,3,5]"
create parser.make_parser (jrep)
ja := Void
ja ?= parser.parse
assert ("ja /= Void", ja /= Void)
ll2 ?= json.object (ja, Void)
assert ("ll2 /= Void", ll2 /= Void)
--ll.compare_objects
--ll2.compare_objects
assert ("ll2.is_equal (ll)", ll2.is_equal (ll))
end
test_json_object is
local
t, t2: HASH_TABLE [ANY, UC_STRING]
i: INTEGER
ucs_key, ucs: UC_STRING
a: ARRAY [INTEGER]
jo: JSON_OBJECT
jn: JSON_NUMBER
js_key, js: JSON_STRING
ja: JSON_ARRAY
jrep: STRING
parser: JSON_PARSER
do
-- Eiffel value -> JSON value -> JSON representation
-- Note: Currently there is now way of creating a JSON_OBJECT from
-- a DS_HASH_TABLE, so we do it manually.
-- t = {"name": "foobar", "size": 42, "contents", [0, 1, 1, 2, 3, 5]}
create jo.make
create js_key.make_json ("name")
create js.make_json ("foobar")
jo.put (js, js_key)
create js_key.make_json ("size")
create jn.make_integer (42)
jo.put (jn, js_key)
create js_key.make_json ("contents")
create ja.make_array
create jn.make_integer (0)
ja.add (jn)
create jn.make_integer (1)
ja.add (jn)
create jn.make_integer (1)
ja.add (jn)
create jn.make_integer (2)
ja.add (jn)
create jn.make_integer (3)
ja.add (jn)
create jn.make_integer (5)
ja.add (jn)
jo.put (ja, js_key)
assert ("jo /= Void", jo /= Void)
assert ("jo.representation.is_equal (%"{%"size%":42,%"contents%":[0,1,1,2,3,5],%"name%":%"foobar%"}%")", jo.representation.is_equal ("{%"size%":42,%"contents%":[0,1,1,2,3,5],%"name%":%"foobar%"}"))
-- Eiffel value -> JSON value -> JSON representation with factory
create t.make (3)
create ucs_key.make_from_string ("name")
create ucs.make_from_string ("foobar")
t.put (ucs, ucs_key)
create ucs_key.make_from_string ("size")
i := 42
t.put (i, ucs_key)
create ucs_key.make_from_string ("contents")
a := <<0, 1, 1, 2, 3, 5>>
t.put (a, ucs_key)
jo := Void
jo ?= json.value (t)
assert ("jo /= Void", jo /= Void)
assert ("jo.representation.is_equal (%"{%"size%":42,%"contents%":[0,1,1,2,3,5],%"name%":%"foobar%"}%")", jo.representation.is_equal ("{%"size%":42,%"contents%":[0,1,1,2,3,5],%"name%":%"foobar%"}"))
-- JSON representation -> JSON value -> Eiffel value -> JSON value -> JSON representation
jrep := "{%"size%":42,%"contents%":[0,1,1,2,3,5],%"name%":%"foobar%"}"
create parser.make_parser (jrep)
jo := Void
jo ?= parser.parse
assert ("jo /= Void", jo /= Void)
t2 ?= json.object (jo, Void)
assert ("t2 /= Void", t2 /= Void)
jo ?= json.value (t2)
assert ("jo /= Void", jo /= Void)
assert ("jrep.is_equal (jo.representation)", jrep.is_equal (jo.representation))
end
test_json_failed_json_conversion is
-- Test converting an Eiffel object to JSON that is based on a class
-- for which no JSON converter has been registered.
local
gv: KL_GOBO_VERSION
jv: JSON_VALUE
exception: BOOLEAN
do
if not exception then
create gv
jv := json.value (gv)
else
assert ("exceptions.is_developer_exception", exceptions.is_developer_exception)
assert ("exceptions.is_developer_exception_of_name", exceptions.is_developer_exception_of_name ("eJSON exception: Failed to convert Eiffel object to a JSON_VALUE: KL_GOBO_VERSION"))
end
rescue
exception := True
retry
end
test_json_failed_eiffel_conversion is
-- Test converting from a JSON value to an Eiffel object based on a
-- class for which no JSON converter has been registered.
local
gv: KL_GOBO_VERSION
jo: JSON_OBJECT
exception: BOOLEAN
do
if not exception then
create jo.make
gv ?= json.object (jo, "KL_GOBO_VERSION")
else
assert ("exceptions.is_developer_exception", exceptions.is_developer_exception)
assert ("exceptions.is_developer_exception_of_name", exceptions.is_developer_exception_of_name ("eJSON exception: Failed to convert JSON_VALUE to an Eiffel object: JSON_OBJECT -> KL_GOBO_VERSION"))
end
rescue
exception := True
retry
end
end -- class TEST_JSON_CORE

49
contrib/library/text/parser/json/test/getest/test_json_custom_classes.e Normal file
View File

@@ -0,0 +1,49 @@
class TEST_JSON_CUSTOM_CLASSES
inherit
SHARED_EJSON
TS_TEST_CASE
create
make_default
feature {NONE} -- Initialization
make is
-- Create test object.
do
end
feature -- Test
test_custom_classes is
local
bc: BOOK_COLLECTION
jbc: JSON_BOOK_CONVERTER
jbcc: JSON_BOOK_COLLECTION_CONVERTER
jac: JSON_AUTHOR_CONVERTER
jo: JSON_OBJECT
parser: JSON_PARSER
jrep: STRING
do
create jbc.make
json.add_converter (jbc)
create jbcc.make
json.add_converter (jbcc)
create jac.make
json.add_converter (jac)
jrep := "{%"name%":%"Test collection%",%"books%":[{%"title%":%"eJSON: The Definitive Guide%",%"isbn%":%"123123-413243%",%"author%":{%"name%":%"Foo Bar%"}}]}"
create parser.make_parser (jrep)
jo := Void
jo ?= parser.parse
assert ("jo /= Void", jo /= Void)
bc := Void
bc ?= json.object (jo, "BOOK_COLLECTION")
assert ("bc /= Void", bc /= Void)
jo ?= json.value (bc)
assert ("jo /= Void", jo /= Void)
assert ("JSON representation is correct", jo.representation.is_equal ("{%"books%":[{%"title%":%"eJSON: The Definitive Guide%",%"isbn%":%"123123-413243%",%"author%":{%"name%":%"Foo Bar%"}}],%"name%":%"Test collection%"}"))
end
end -- class TEST_JSON_CUSTOM_CLASS

27
contrib/library/text/parser/json/test/run_autotest.bat Normal file
View File

@@ -0,0 +1,27 @@
@echo off
setlocal
set TMP_EC_SCRIPT_FILENAME=%~dp0.tmp_ec_scripting
cd %~dp0autotest\test_suite
set TMP_EC_CMD=ec -config test_suite-safe.ecf -target test_suite -batch
echo # Fresh Compilation
%TMP_EC_CMD% -batch -clean -freeze -c_compile -project_path . > %~dp0autotest.compile.log 2>&1
rem Build scripting for freeze + testing
rem ------------------------------------
rem Testing
echo T > %TMP_EC_SCRIPT_FILENAME%
rem Execute
echo e >> %TMP_EC_SCRIPT_FILENAME%
rem Quit
echo Q >> %TMP_EC_SCRIPT_FILENAME%
echo # Execute test_suite
type %TMP_EC_SCRIPT_FILENAME% | %TMP_EC_CMD% -loop 1> :NULL 2> %~dp0autotest.testing.log
type %~dp0autotest.testing.log
cd %~dp0
del %TMP_EC_SCRIPT_FILENAME%
endlocal