231 lines
7.2 KiB
Elixir
231 lines
7.2 KiB
Elixir
defmodule RDF.LiteralTest do
|
|
use ExUnit.Case
|
|
|
|
import RDF.Sigils
|
|
import RDF.TestLiterals
|
|
|
|
alias RDF.{Literal}
|
|
alias RDF.NS.XSD
|
|
|
|
doctest RDF.Literal
|
|
|
|
|
|
describe "construction by type inference" do
|
|
test "creating an string literal" do
|
|
string_literal = Literal.new("foo")
|
|
assert string_literal.value == "foo"
|
|
assert string_literal.datatype == XSD.string
|
|
end
|
|
|
|
test "creating an integer by type inference" do
|
|
int_literal = Literal.new(42)
|
|
assert int_literal.value == 42
|
|
assert int_literal.datatype == XSD.integer
|
|
end
|
|
|
|
test "creating a boolean by type inference" do
|
|
int_literal = Literal.new(true)
|
|
assert int_literal.value == true
|
|
assert int_literal.datatype == XSD.boolean
|
|
|
|
int_literal = Literal.new(false)
|
|
assert int_literal.value == false
|
|
assert int_literal.datatype == XSD.boolean
|
|
end
|
|
|
|
end
|
|
|
|
describe "construction with an explicit unknown datatype" do
|
|
literal = Literal.new("custom typed value", datatype: "http://example/dt")
|
|
assert literal.value == "custom typed value"
|
|
assert literal.datatype == ~I<http://example/dt>
|
|
end
|
|
|
|
describe "construction with an explicit known (XSD) datatype" do
|
|
test "creating a boolean" do
|
|
bool_literal = Literal.new("true", datatype: XSD.boolean)
|
|
assert bool_literal.value == true
|
|
assert bool_literal.datatype == XSD.boolean
|
|
|
|
bool_literal = Literal.new(true, datatype: XSD.boolean)
|
|
assert bool_literal.value == true
|
|
assert bool_literal.datatype == XSD.boolean
|
|
|
|
bool_literal = Literal.new("false", datatype: XSD.boolean)
|
|
assert bool_literal.value == false
|
|
assert bool_literal.datatype == XSD.boolean
|
|
|
|
bool_literal = Literal.new(false, datatype: XSD.boolean)
|
|
assert bool_literal.value == false
|
|
assert bool_literal.datatype == XSD.boolean
|
|
end
|
|
|
|
test "creating an integer" do
|
|
int_literal = Literal.new(42, datatype: XSD.integer)
|
|
assert int_literal.value == 42
|
|
assert int_literal.datatype == XSD.integer
|
|
|
|
int_literal = Literal.new("42", datatype: XSD.integer)
|
|
assert int_literal.value == 42
|
|
assert int_literal.datatype == XSD.integer
|
|
|
|
int_literal = Literal.new(true, datatype: XSD.integer)
|
|
assert int_literal.value == 1
|
|
assert int_literal.datatype == XSD.integer
|
|
int_literal = Literal.new(false, datatype: XSD.integer)
|
|
assert int_literal.value == 0
|
|
assert int_literal.datatype == XSD.integer
|
|
end
|
|
|
|
end
|
|
|
|
describe "language-tags" do
|
|
test "creating a string literal with a language tag" do
|
|
literal = Literal.new("Eule", language: "de")
|
|
assert literal.value == "Eule"
|
|
assert literal.datatype == RDF.langString
|
|
assert literal.language == "de"
|
|
end
|
|
|
|
test "when given a language, but the value is not a string, language is ignored" do
|
|
literal = Literal.new(1, language: "de")
|
|
assert literal.value == 1
|
|
assert literal.datatype == XSD.integer
|
|
refute literal.language
|
|
end
|
|
|
|
test "construction of an other than rdf:langString typed and language-tagged literal fails" do
|
|
assert_raise ArgumentError, fn ->
|
|
Literal.new("Eule", datatype: XSD.string, language: "de")
|
|
end
|
|
end
|
|
|
|
test "construction of a rdf:langString typed literal without language fails" do
|
|
assert_raise ArgumentError, fn ->
|
|
Literal.new("Eule", datatype: RDF.langString)
|
|
end
|
|
end
|
|
end
|
|
|
|
describe "language" do
|
|
Enum.each literals(:all_plain_lang), fn literal ->
|
|
@tag literal: literal
|
|
test "#{inspect literal} has correct language", %{literal: literal} do
|
|
assert literal.language == "en"
|
|
end
|
|
end
|
|
Enum.each literals(:all) -- literals(:all_plain_lang), fn literal ->
|
|
@tag literal: literal
|
|
test "#{inspect literal} has no language", %{literal: literal} do
|
|
assert is_nil(literal.language)
|
|
end
|
|
end
|
|
|
|
test "language get lower-cased" do
|
|
assert Literal.new("Upper", language: "EN").language == "en"
|
|
assert Literal.new("Upper", %{language: "EN"}).language == "en"
|
|
end
|
|
end
|
|
|
|
describe "datatype" do
|
|
Enum.each literals(:all_simple), fn literal ->
|
|
@tag literal: literal
|
|
test "simple literal #{inspect literal} has datatype xsd:string", %{literal: literal} do
|
|
assert literal.datatype == XSD.string
|
|
end
|
|
end
|
|
|
|
%{
|
|
123 => "integer",
|
|
true => "boolean",
|
|
false => "boolean",
|
|
9223372036854775807 => "integer",
|
|
3.1415 => "double",
|
|
~D[2017-04-13] => "date",
|
|
~N[2017-04-14 15:32:07] => "dateTime",
|
|
~T[01:02:03] => "time"
|
|
}
|
|
|> Enum.each(fn {value, type} ->
|
|
@tag data: %{literal: literal = Literal.new(value), type: type}
|
|
test "#{inspect literal} has datatype xsd:#{type}",
|
|
%{data: %{literal: literal, type: type}} do
|
|
assert literal.datatype == apply(XSD, String.to_atom(type), [])
|
|
end
|
|
end)
|
|
end
|
|
|
|
describe "has_datatype?" do
|
|
Enum.each literals(~W[all_simple all_plain_lang]a), fn literal ->
|
|
@tag literal: literal
|
|
test "#{inspect literal} has no datatype", %{literal: literal} do
|
|
refute Literal.has_datatype?(literal)
|
|
end
|
|
end
|
|
|
|
Enum.each literals(:all) -- literals(~W[all_simple all_plain_lang]a), fn literal ->
|
|
@tag literal: literal
|
|
test "#{inspect literal} has a datatype", %{literal: literal} do
|
|
assert Literal.has_datatype?(literal)
|
|
end
|
|
end
|
|
end
|
|
|
|
describe "plain?" do
|
|
Enum.each literals(:all_plain), fn literal ->
|
|
@tag literal: literal
|
|
test "#{inspect literal} is plain", %{literal: literal} do
|
|
assert Literal.plain?(literal)
|
|
end
|
|
end
|
|
Enum.each literals(:all) -- literals(:all_plain), fn literal ->
|
|
@tag literal: literal
|
|
test "#{inspect literal} is not plain", %{literal: literal} do
|
|
refute Literal.plain?(literal)
|
|
end
|
|
end
|
|
end
|
|
|
|
describe "simple?" do
|
|
Enum.each literals(:all_simple), fn literal ->
|
|
@tag literal: literal
|
|
test "#{inspect literal} is simple", %{literal: literal} do
|
|
assert Literal.simple?(literal)
|
|
end
|
|
end
|
|
Enum.each literals(:all) -- literals(:all_simple), fn literal ->
|
|
@tag literal: literal
|
|
test "#{inspect literal} is not simple", %{literal: literal} do
|
|
refute Literal.simple?(literal)
|
|
end
|
|
end
|
|
end
|
|
|
|
describe "String.Chars protocol implementation" do
|
|
Enum.each values(:all_plain), fn value ->
|
|
@tag value: value
|
|
test "returns String representation of #{inspect value}", %{value: value} do
|
|
assert to_string(apply(Literal, :new, value)) == List.first(value)
|
|
end
|
|
end
|
|
|
|
%{
|
|
literal(:int) => "123",
|
|
literal(:true) => "true",
|
|
literal(:false) => "false",
|
|
literal(:long) => "9223372036854775807",
|
|
literal(:double) => "3.1415",
|
|
literal(:date) => "2017-04-13",
|
|
literal(:datetime) => "2017-04-14 15:32:07",
|
|
literal(:time) => "01:02:03"
|
|
}
|
|
|> Enum.each(fn {literal, rep} ->
|
|
@tag data: %{literal: literal, rep: rep}
|
|
test "returns String representation of #{inspect literal} value",
|
|
%{data: %{literal: literal, rep: rep}} do
|
|
assert to_string(literal) == rep
|
|
end
|
|
end)
|
|
|
|
end
|
|
|
|
end
|