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

removed "getest" since it is duplication with autotest (and we use mainly the later for regression testing)

Browse Source
This commit is contained in:
Jocelyn Fiat
2012-08-08 09:13:33 +02:00
parent 8b33c77008
commit b6464cf5e7
15 changed files with 0 additions and 1259 deletions
Download Patch File Download Diff File Expand all files Collapse all files

24
test/getest/author.e
View File

@@ -1,24 +0,0 @@
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
test/getest/book.e
View File

@@ -1,40 +0,0 @@
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
test/getest/book_collection.e
View File

@@ -1,82 +0,0 @@
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
test/getest/ec_compile.bat
View File

@@ -1,11 +0,0 @@
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
test/getest/ec_compile.sh
View File

@@ -1,5 +0,0 @@
#!/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
test/getest/ejson_test-win.cfg
View File

@@ -1,17 +0,0 @@
-- 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
test/getest/ejson_test.cfg
View File

@@ -1,17 +0,0 @@
-- 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
test/getest/ejson_test.ecf
View File

@@ -1,21 +0,0 @@
<?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>

55
test/getest/json_author_converter.e
View File

@@ -1,55 +0,0 @@
indexing
description: "A JSON converter for AUTHOR"
author: "Paul Cohen"
date: "$Date$"
revision: "$Revision$"
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

80
test/getest/json_book_collection_converter.e
View File

@@ -1,80 +0,0 @@
indexing
description: "A JSON converter for BOOK_COLLECTION"
author: "Paul Cohen"
date: "$Date$"
revision: "$Revision$"
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

74
test/getest/json_book_converter.e
View File

@@ -1,74 +0,0 @@
indexing
description: "A JSON converter for BOOK"
author: "Paul Cohen"
date: "$Date$"
revision: "$Revision$"
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
test/getest/readme.txt
View File

@@ -1,10 +0,0 @@
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
test/getest/test_ds.e
View File

@@ -1,71 +0,0 @@
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
test/getest/test_json_core.e
View File

@@ -1,703 +0,0 @@
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
test/getest/test_json_custom_classes.e
View File

@@ -1,49 +0,0 @@
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