public ResourceFactoryResponder()
{
itsUriRefResponse = new UriRefStub();
itsBlankNodeResponse = new BlankNodeStub();
itsTypedLiteralResponse = new TypedLiteralStub();
itsPlainLiteralResponse = new PlainLiteralStub();
}
public void writeCallsWriterWritePlainLiteralWithCorrectArgumentsWithLanguage() {
RdfWriterStore writer = new RdfWriterStore();
PlainLiteral instance = new PlainLiteral("whizz", "gr");
instance.Write(writer);
Assert.IsTrue( writer.WasWritePlainLiteralCalledWith("whizz", "gr") );
}
public void matchesCallsMatchesPlainLiteralWithLanguageOnSpecifier() {
ResourceSpecifierStore specifier = new ResourceSpecifierStore();
PlainLiteral instance = new PlainLiteral("whizz", "de");
instance.Matches( specifier );
Assert.IsTrue( specifier.WasMatchesPlainLiteralCalledWith("whizz", "de") );
}
public void matchesReturnsResponseFromMatchesPlainLiterallWithLanguageCall() {
ResourceSpecifierResponder specifierTrue = new ResourceSpecifierResponder(true);
ResourceSpecifierResponder specifierFalse = new ResourceSpecifierResponder(false);
PlainLiteral instance = new PlainLiteral("whizz", "de");
Assert.IsTrue( instance.Matches( specifierTrue ));
Assert.IsFalse( instance.Matches( specifierFalse ));
}
private void EnsureLanguageExistsInDb(PlainLiteral node)
{
int hash = node.GetLanguage().GetHashCode();
MySqlCommand cmd = new MySqlCommand("INSERT IGNORE INTO Languages (hash, value) VALUES (" +
hash + ", '" + node.GetLanguage() + "')", itsConn);
cmd.ExecuteNonQuery();
}
public void writeCallsWriterWritePlainLiteralOnceWithLanguage() {
RdfWriterCounter writer = new RdfWriterCounter();
PlainLiteral instance = new PlainLiteral("whizz", "en");
instance.Write(writer);
Assert.AreEqual( 1, writer.WritePlainLiteralLanguageCalled );
}
public void EvaluateReturnsGraphMember()
{
PlainLiteral member = new PlainLiteral("scooby");
GraphMemberExpression constraint = new GraphMemberExpression(member);
Bindings bindings = new Bindings();
Assert.AreEqual(member, constraint.Evaluate(bindings));
}
/// <summary>
/// Generates the triples.
/// </summary>
/// <param name="outputGraph">The Rdf graph.</param>
private void GenerateTriples(Graph outputGraph)
{
//If e.subject is empty, then e.subject := bnodeid(identifier := generated-blank-node-id()).
//The following can then be performed in any order:
// * If e.URI != rdf:Description then the following statement is added to the graph:
// e.subject.string-value <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> e.URI-string-value .
// * If there is an attribute a in propertyAttr with a.URI == rdf:type then u:=uri(identifier:=resolve(a.string-value)) and the following tiple is added to the graph:
// e.subject.string-value <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> u.string-value .
// * For each attribute a matching propertyAttr (and not rdf:type), the Unicode string a.string-value SHOULD be in Normal Form C[NFC], o := literal(literal-value := a.string-value, literal-language := e.language) and the following statement is added to the graph:
// e.subject.string-value a.URI-string-value o.string-value .
Subject subject = GetSubject();
if (subject != null)
{
innerElement.Subject = subject;
}
if (innerElement.Subject == null)
{
innerElement.Subject = new BlankNode();
}
if (innerElement.Uri != DescriptionUri)
{
AddTriple(outputGraph, innerElement.Subject, TypeUri, innerElement.Uri);
}
//propertyAttr = anyURI - ( coreSyntaxTerms | rdf:Description | rdf:li | oldTerms )
IEnumerable <EventAttribute> propertyAttr =
innerElement.Attributes.Where(tuple => tuple.Uri != DescriptionUri &&
tuple.Uri != LiUri &&
Production.CoreSyntaxTerms.Where(attr => attr == tuple.Uri).Count() == 0 &&
Production.OldTerms.Where(attr => attr == tuple.Uri).Count() == 0);
EventAttribute a = propertyAttr.
Where(tuple => tuple.Uri == TypeUri).FirstOrDefault();
if (a != null)
{
RDFUriReference u = Production.Resolve(innerElement, a.StringValue);
AddTriple(outputGraph, innerElement.Subject, TypeUri, u);
}
foreach (EventAttribute attr in
propertyAttr.Where(tuple => tuple.Uri != TypeUri))
{
PlainLiteral o = new PlainLiteral(attr.StringValue, innerElement.Language);
AddTriple(outputGraph, innerElement.Subject, attr.Uri, o);
}
}
private IList GetNodesDenoting(Resource theResource, bool onlyTheBest)
{
ArrayList theNodes = new ArrayList();
MySqlCommand cmd = new MySqlCommand(
"SELECT rn.nodeHash, rn.nodeType, u.uri, pl.value, l.value, tl.value, t.value " +
"FROM resourcenodes rn " +
"LEFT OUTER JOIN UriRefs u ON rn.nodeHash=u.hash AND rn.nodeType='u' " +
"LEFT OUTER JOIN Plainliterals pl ON rn.nodeHash = pl.hash AND rn.nodeType='p' " +
"LEFT OUTER JOIN Languages l ON pl.languageHash = l.hash " +
"LEFT OUTER JOIN TypedLiterals tl ON rn.nodehash = tl.hash AND rn.nodeType = 't' " +
"LEFT OUTER JOIN DataTypes t ON tl.datatypeHash = t.hash " +
"WHERE rn.graphId = " + itsHashCode + " AND rn.resourceHash = " + theResource.GetHashCode() + (onlyTheBest == true ? " LIMIT 1" : ""), itsConn);
MySqlDataReader dataReader = cmd.ExecuteReader();
int nodeHash;
char nodeType;
while (dataReader.Read())
{
nodeHash = dataReader.GetInt32(0);
nodeType = dataReader.GetChar(1);
GraphMember node = null;
switch (nodeType)
{
case 'u':
node = new UriRef(dataReader.GetString(2));
break;
case 'b':
node = new BlankNode(nodeHash);
break;
case 'p':
node = new PlainLiteral(dataReader.GetString(3), dataReader.GetString(4));
break;
case 't':
node = new TypedLiteral(dataReader.GetString(5), dataReader.GetString(6));
break;
}
theNodes.Add(node);
}
dataReader.Close();
return(theNodes);
}
/// <summary>
/// Generates the triples.
/// </summary>
/// <param name="outputGraph">The Rdf graph.</param>
private void GenerateTriples(Graph outputGraph)
{
//For element e, and the text event t. The Unicode string t.string-value SHOULD
//be in Normal Form C[NFC].
//If the rdf:datatype attribute d is given then o :=
//typed-literal(literal-value := t.string-value, literal-datatype := d.string-value)
//otherwise o := literal(literal-value := t.string-value, literal-language := e.language)
//and the following statement is added to the graph:
//e.parent.subject.string-value e.URI-string-value o.string-value .
// If the rdf:ID attribute a is given, the above statement is reified
//with i := uri(identifier := resolve(e, concat("#", a.string-value)))
//using the reification rules in section 7.3 and e.subject := i.
Subject s = innerElement.Parent.Subject;
RDFUriReference p = innerElement.Uri;
Node o = null;
EventAttribute d = innerElement.Attributes.
Where(tuple => tuple.Uri == DatatypeUri).FirstOrDefault();
if (d != null)
{
o = new TypedLiteral(innerElement.StringValue,
Production.Resolve(innerElement, d.StringValue));
}
else
{
o = new PlainLiteral(innerElement.StringValue, innerElement.Language);
}
AddTriple(outputGraph, s, p, o);
EventAttribute a = innerElement.Attributes.
Where(tuple => tuple.Uri == IDUri).FirstOrDefault();
if (a != null)
{
RDFUriReference i = Production.Resolve(innerElement, ("#" + a.StringValue));
Production.Reify(s, p, o, i, outputGraph);
}
}
public void neverEqualsInstanceOfSameClassButDifferentLexicalValueAndNoLanguage() {
PlainLiteral instance = new PlainLiteral("whizz");
PlainLiteral other = new PlainLiteral("bang");
Assert.IsFalse( instance.Equals(other) );
}
public void alwaysEqualsSelf() {
PlainLiteral instance = new PlainLiteral("whizz");
Assert.IsTrue( instance.Equals(instance) );
}
public void neverEqualsInstanceOfDifferentClass() {
PlainLiteral instance = new PlainLiteral("whizz");
Object obj = new Object();
Assert.IsFalse( instance.Equals(obj) );
}
public void neverEqualsNull() {
PlainLiteral instance = new PlainLiteral("whizz");
Assert.IsFalse( instance.Equals(null) );
}
public void languageDefaultsToNull() {
PlainLiteral node = new PlainLiteral("whizz");
Assert.AreEqual(null, node.GetLanguage());
}
public void neverEqualsInstanceOfSameClassWithSameLexicalValueAndDifferentLanguage() {
PlainLiteral instance = new PlainLiteral("whizz", "en");
PlainLiteral other = new PlainLiteral("whizz", "fr");
Assert.IsFalse( instance.Equals(other) );
}
public void ExecuteQuery()
{
ArrayList solutions = new ArrayList();
if (SolutionIsPossible)
{
MySqlDataReader dataReader = null;
try {
dataReader = itsTriples.ExecuteSqlQuery(itsQuerySql);
while (dataReader.Read())
{
QuerySolution solution = new QuerySolution();
int col = 0;
foreach (Variable var in itsSelectedVariables)
{
object resourceHash = dataReader.GetValue(col);
if (!resourceHash.Equals(DBNull.Value))
{
Resource resource = new Resource(Convert.ToInt32(resourceHash));
solution[var.Name] = resource;
int nodeHash = dataReader.GetInt32(col + 1);
char nodeType = dataReader.GetChar(col + 2);
string lexicalValue = dataReader.GetString(col + 3);
object rawSubValue = dataReader.GetValue(col + 4);
string subValue = null;
if (!rawSubValue.Equals(DBNull.Value))
{
subValue = (string)rawSubValue;
}
GraphMember node = null;
switch (nodeType)
{
case 'u':
node = new UriRef(lexicalValue);
break;
case 'b':
node = new BlankNode(nodeHash);
break;
case 'p':
node = new PlainLiteral(lexicalValue, subValue);
break;
case 't':
node = new TypedLiteral(lexicalValue, subValue);
break;
}
solution.SetNode(var.Name, node);
}
col += 5;
}
solutions.Add(solution);
}
}
catch (MySqlException e) {
throw new ApplicationException("Error executing '" + itsQuerySql + "' for query " + itsQuery, e);
}
finally {
if (null != dataReader)
{
dataReader.Close();
}
}
}
itsSolutions = solutions.GetEnumerator();
}
/// <summary>
/// Creates a new PlainLiteral object that is a copy of the current instance.
/// </summary>
/// <returns>A new PlainLiteral object that is a copy of the current instance.</returns>
public override object Clone()
{
PlainLiteral clonedLiteral = new PlainLiteral(this.LexicalForm, this.LanguageTag);
return(clonedLiteral);
}
public override Statement MakeStatement(UriRef subject, UriRef predicate, PlainLiteral value)
{
++MakeStatementUUPCalled;
return(new StatementStub());
}
public override Statement MakeStatement(UriRef subject, UriRef predicate, PlainLiteral value)
{
itsMethodCalls.RecordMethodCall("MakeStatement", subject, predicate, value);
return(new StatementStub());
}
/// <summary>
/// Generates the triples.
/// </summary>
/// <param name="outputGraph">The Rdf graph.</param>
private void GenerateTriples(Graph outputGraph)
{
//If there are no attributes or only the optional rdf:ID attribute i then
//o := literal(literal-value:="", literal-language := e.language) and
//the following statement is added to the graph:
//e.parent.subject.string-value e.URI-string-value o.string-value .
EventAttribute i = innerElement.Attributes.
Where(tuple => tuple.Uri == IDUri).FirstOrDefault();
if (innerElement.Attributes.Count() == 0 ||
(innerElement.Attributes.Count() == 1 && i != null))
{
Subject s = innerElement.Parent.Subject;
RDFUriReference p = innerElement.Uri;
Node o = new PlainLiteral(string.Empty, innerElement.Language);
AddTriple(outputGraph, s, p, o);
//and then if i is given, the above statement is reified with
//uri(identifier := resolve(e, concat("#", i.string-value)))
//using the reification rules
if (i != null)
{
RDFUriReference elementUri = Production.Resolve(innerElement, ("#" + i.StringValue));
Production.Reify(s, p, o, elementUri, outputGraph);
}
}
else
{
Subject r = GetSubject();
//For all propertyAttr attributes a (in any order)
//If a.URI == rdf:type then u:=uri(identifier:=resolve(a.string-value)) and the following triple is added to the graph:
//r.string-value <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> u.string-value .
//Otherwise Unicode string a.string-value SHOULD be in Normal Form C[NFC],
//o := literal(literal-value := a.string-value, literal-language := e.language) and the following statement is added to the graph:
//r.string-value a.URI-string-value o.string-value .
//propertyAttr = anyURI - ( coreSyntaxTerms | rdf:Description | rdf:li | oldTerms )
IEnumerable <EventAttribute> propertyAttr = innerElement.Attributes.
Where(tuple => tuple.Uri != DescriptionUri &&
tuple.Uri != LiUri &&
(Production.CoreSyntaxTerms.Where(attr => attr == tuple.Uri).Count() == 0) &&
(Production.OldTerms.Where(attr => attr == tuple.Uri).Count() == 0));
foreach (EventAttribute a in propertyAttr)
{
if (a.Uri == TypeUri)
{
RDFUriReference u = Production.Resolve(innerElement, a.StringValue);
AddTriple(outputGraph, r, TypeUri, u);
}
//Attributes except rdf:resource and rdf:nodeID
else if (!(a.Uri == ResourceUri || a.Uri == NodeIDUri))
{
Node literal = new PlainLiteral(a.StringValue, innerElement.Language);
AddTriple(outputGraph, r, a.Uri, literal);
}
}
//Add the following statement to the graph:
//e.parent.subject.string-value e.URI-string-value r.string-value .
//and then if rdf:ID attribute i is given, the above statement is reified with uri(identifier := resolve(e, concat("#", i.string-value))) using the reification rules
Subject s = innerElement.Parent.Subject;
RDFUriReference p = innerElement.Uri;
Node o = r;
AddTriple(outputGraph, s, p, o);
if (i != null)
{
RDFUriReference elementUri = Production.Resolve(innerElement, ("#" + i.StringValue));
Production.Reify(s, p, o, elementUri, outputGraph);
}
}
}
public void getHashCodeReturnsSameCodeForDifferentInstancesWithSameLexicalValuesAndSameLanguage() {
PlainLiteral instance = new PlainLiteral("whizz", "en");
PlainLiteral other = new PlainLiteral("whizz", "en");
Assert.IsTrue( instance.GetHashCode() == other.GetHashCode() );
}
public void getHashCodeReturnsDifferentCodeForDifferentInstancesWithSameLexicalValuesButDifferentLanguages() {
PlainLiteral instance = new PlainLiteral("whizz", "en");
PlainLiteral other = new PlainLiteral("whizz", "fr");
Assert.IsFalse( instance.GetHashCode() == other.GetHashCode() );
}
public void getHashCodeReturnsDifferentCodeForDifferentInstancesWithDifferentLexicalValues() {
PlainLiteral instance = new PlainLiteral("whizz");
PlainLiteral other = new PlainLiteral("bang");
Assert.IsFalse( instance.GetHashCode() == other.GetHashCode() );
}
public void alwaysEqualsInstanceOfSameClassWithSameLexicalValueAndNoLanguage() {
PlainLiteral instance = new PlainLiteral("whizz");
PlainLiteral other = new PlainLiteral("whizz");
Assert.IsTrue( instance.Equals(other) );
}
public override Statement MakeStatement(BlankNode subject, UriRef predicate, PlainLiteral value)
{
return(new StatementStub());
}
public void labelIsLexicalValue() {
PlainLiteral node = new PlainLiteral("whizz");
Assert.AreEqual("whizz", node.GetLabel());
}
public void languageSpecifiedInConstructor() {
PlainLiteral node = new PlainLiteral("whizz", "fr");
Assert.AreEqual("fr", node.GetLanguage());
}
public bool WasMakeStatementCalledWith(UriRef subject, UriRef predicate, PlainLiteral value)
{
return(itsMethodCalls.WasMethodCalledWith("MakeStatement", subject, predicate, value));
}
