def test_prev(self, simple):
        """ Test prev property """
        # self.TEI.parse()
        # Normal passage checking
        p = self.TEI.getTextualNode(["2", "40", "8"], simple=simple)
        self.assertEqual(str(p.prev.reference), "2.40.7")
        p = self.TEI.getTextualNode(["2", "40"], simple=simple)
        self.assertEqual(str(p.prev.reference), "2.39")
        p = self.TEI.getTextualNode(["2"], simple=simple)
        self.assertEqual(str(p.prev.reference), "1")

        # test failing passage
        p = self.TEI.getTextualNode(["1", "pr", "1"], simple=simple)
        self.assertEqual(p.prev, None)
        p = self.TEI.getTextualNode(["1", "pr"], simple=simple)
        self.assertEqual(p.prev, None)
        p = self.TEI.getTextualNode(["1"], simple=simple)
        self.assertEqual(p.prev, None)

        # First child should get to parent's prev last child
        p = self.TEI.getTextualNode(["1", "1", "1"], simple=simple)
        self.assertEqual(str(p.prev.reference), "1.pr.22")

        # Beginning of lowest level passage and beginning of parent level
        p = self.TEI.getTextualNode(["2", "pr", "sa"], simple=simple)
        self.assertEqual(str(p.prev.reference), "1.39.8")

 def config_string(self):
     """Generate a '|' delimited string of instance attributes, for saving to config.ini."""
     return '|'.join([
         self.name, self.url, self.api_key, self.cat_ids, str(int(self.enabled)),
         self.search_mode, str(int(self.search_fallback)),
         str(int(self.enable_daily)), str(int(self.enable_backlog)), str(int(self.enable_manualsearch))
     ])

 def select(self, query, format="sparql"):
     # FIXME: workaround for the fact that rdflib select uses FROM
     # <%s> differently than Sesame/Fuseki. We remove the 'FROM
     # <%s>' part from the query and instead get a context graph
     # for the same URI.
     re_fromgraph = re.compile(r" FROM <(?P<graphuri>[^>]+)> ")
     graphuri = None
     m = re_fromgraph.search(query)
     if m:
         graphuri = m.group("graphuri")
         query = re_fromgraph.sub(" ", query)
     try:
         res = self._getcontextgraph(graphuri).query(query)
     except pyparsing.ParseException as e:
         raise errors.SparqlError(e)
     if format == "sparql":
         return res.serialize(format="xml")
     elif format == "json":
         return res.serialize(format="json")
     else:
         # or just
         # return self._sparql_results_to_list(res.serialize(format="xml"))
         l = []
         for r in res.bindings:
             d = {}
             for (key, val) in r.items():
                 d[str(key)] = str(val)
             l.append(d)
         return l

def test_scan_video_invalid_extension(movies, tmpdir, monkeypatch):
    monkeypatch.chdir(str(tmpdir))
    movie_name = os.path.splitext(movies['man_of_steel'].name)[0] + '.mp3'
    tmpdir.ensure(movie_name)
    with pytest.raises(ValueError) as excinfo:
        scan_video(movie_name)
    assert str(excinfo.value) == '.mp3 is not a valid video extension'

    def build_uri(self, base, matches):
        if not base:
            return None
        if self.uriTemplate:
            expanded = str(self.uriTemplate)
        elif self.fragmentTemplate:
            if "#" in base:
                base += self.space.fragmentSeparator
            else:
                base += "#"
            expanded = base + str(self.fragmentTemplate)
        else:
            return None

        expanded = expanded.replace("{+base}", base)
        for var, value in matches.items():
            slug = self.transform_value(value)
            expanded = expanded.replace("{%s}" % var, slug)
        # if base is eg "http://localhost/res/" and expanded is a
        # /-prefixed relative uri like "/sfs/9999:998", urljoin
        # results in "http://localhost/sfs/9999:998/", not
        # "http://localhost/res/" like you'd expect. So we work
        # around.
        if expanded[0] == "/":
            expanded = expanded[1:]
            
        if expanded.startswith("http://") or expanded.startswith("https://"):
            return urljoin(base, expanded)
        else:
            # see the test integrationLegalURI.CustomCoinstruct.test_1845_50_s.1
            return "%s/%s" % (base, expanded)

def getprevnext(passage, request_urn, output=XML):
    _prev = ""
    _next = ""

    if passage.prev:
        _prev = URN("{}:{}".format(passage.urn.upTo(URN.VERSION), str(passage.prev)))
    if passage.next:
        _next = URN("{}:{}".format(passage.urn.upTo(URN.VERSION), str(passage.next)))

    if output == XML:
        return """
            <GetPrevNext xmlns:tei="http://www.tei-c.org/ns/1.0" xmlns="http://chs.harvard.edu/xmlns/cts">
                <request>
                    <requestName>GetPrevNext</requestName>
                    <requestUrn>{request_urn}</requestUrn>
                </request>
                <reply>
                    <urn>{full_urn}</urn>
                    <prevnext>
                        <prev><urn>{prev}</urn></prev>
                        <next><urn>{next}</urn></next>
                    </prevnext>
                </reply>
            </GetPrevNext>""".format(
            request_urn=request_urn,
            full_urn=str(passage.urn),
            prev=str(_prev),
            next=str(_next)
        )

    def test_first_list(self):
        passage = self.text.getPassage(MyCapytain.common.reference.Reference("2.39"))
        self.assertEqual(str(passage.firstId), "2.39.1", "First reff should be the first")
        self.assertEqual(str(passage.lastId), "2.39.2", "Last reff should be the last")

        passage = self.text.getPassage(MyCapytain.common.reference.Reference("2.39-2.40"))
        self.assertEqual(str(passage.firstId), "2.39.1", "First reff should be the first")
        self.assertEqual(str(passage.lastId), "2.40.8", "Last reff should be the last")

 def test_prevnext_on_close_to_last_passage(self):
     passage = self.text.getPassage(MyCapytain.common.reference.Reference("2.39.2-2.40.5"))
     self.assertEqual(
         str(passage.nextId),
         "2.40.6-2.40.8",
         "Next reff should finish at the end of the text, no matter the length of the reference",
     )
     self.assertEqual(str(passage.prevId), "2.37.9-2.39.1", "Prev reff should be the same length as sibling")

 def test_prevnext_on_close_to_first_passage(self):
     passage = self.text.getPassage(MyCapytain.common.reference.Reference("1.pr.10-1.2.1"))
     self.assertEqual(str(passage.nextId), "1.2.2-1.4.1", "Next reff should be the same length as sibling")
     self.assertEqual(
         str(passage.prevId),
         "1.pr.1-1.pr.9",
         "Prev reff should start at the beginning of the text, no matter the length of the reference",
     )

 def test_highest(self):
     self.assertEqual(
         str((Reference("1.1-1.2.8")).highest), "1.1",
         "1.1 is higher"
     )
     self.assertEqual(
         str((Reference("1.1-2")).highest), "2",
         "2 is higher"
     )

 def test_properties(self):
     a = Reference("[email protected]@Atreus[3]")
     self.assertEqual(str(a.start), "[email protected]")
     self.assertEqual(a.start.list, ["1", "1"])
     self.assertEqual(a.start.subreference[0], "Achilles")
     self.assertEqual(str(a.end), "[email protected][3]")
     self.assertEqual(a.end.list, ["1", "10"])
     self.assertEqual(a.end.subreference[1], 3)
     self.assertEqual(a.end.subreference, ("Atreus", 3))

 def _load_resources(self, resource_path):
     # returns a mapping [resource label] => [resource uri]
     # resource_path is given relative to cwd
     graph = Graph()
     graph.load(resource_path, format='n3')
     d = {}
     for uri, label in graph.subject_objects(RDFS.label):
         d[str(label)] = str(uri)
     return d

 def test_Unicode_Support(self):
     a = Reference("[email protected]καὶ[0][email protected]Ἀλκιβιάδου[3]")
     self.assertEqual(str(a.start), "[email protected]καὶ[0]")
     self.assertEqual(a.start.list, ["1", "1"])
     self.assertEqual(a.start.subreference[0], "καὶ")
     self.assertEqual(str(a.end), "[email protected]Ἀλκιβιάδου[3]")
     self.assertEqual(a.end.list, ["1", "10"])
     self.assertEqual(a.end.subreference[1], 3)
     self.assertEqual(a.end.subreference, ("Ἀλκιβιάδου", 3))

 def test_xml_Work_GetItem(self):
     """ Test access through getItem obj[urn] """
     TI = TextInventory(resource=self.getCapabilities, id="TestInv")
     tg = TI["urn:cts:latinLit:phi1294"]
     self.assertIsInstance(tg["urn:cts:latinLit:phi1294.phi002"], Work)
     self.assertEqual(str(tg["urn:cts:latinLit:phi1294.phi002"].urn), "urn:cts:latinLit:phi1294.phi002")
     self.assertIsInstance(tg["urn:cts:latinLit:phi1294.phi002.perseus-lat2"], Text)
     self.assertEqual(
         str(tg["urn:cts:latinLit:phi1294.phi002.perseus-lat2"].urn), "urn:cts:latinLit:phi1294.phi002.perseus-lat2"
     )

def mock_volume(override=None):
    volume_model = {
        "id": str(uuid.uuid4()),
        "sizeInKb": (8 * constants.GIGABYTE) // constants.KILOBYTE,
        "storagePoolId": str(uuid.uuid4()),
        "useRmcache": False,
        "volumeType": constants.VOLUME_TYPE_THICK,
        "mappedSdcInfo": []
    }
    volume_model.update(override or {})
    return volume_model

 def test_str(self):
     a = Citation(name="book", xpath="/tei:div[@n=\"?\"]", scope="/tei:TEI/tei:body/tei:text/tei:div")
     self.assertEqual(
         str(a),"<tei:cRefPattern n=\"book\" matchPattern=\"(\\w+)\" replacementPattern=\"#xpath(/tei:TEI/tei:body/tei:text/tei:div/tei:div[@n=\"$1\"])\"><tei:p>This pointer pattern extracts book</tei:p></tei:cRefPattern>"
     )
     b = Citation(name="chapter", xpath="/tei:div[@n=\"?\"]", scope="/tei:TEI/tei:body/tei:text/tei:div/tei:div[@n=\"?\"]")
     self.assertEqual(
         str(b),"<tei:cRefPattern n=\"chapter\" matchPattern=\"(\\w+)\.(\\w+)\" replacementPattern=\"#xpath(/tei:TEI/tei:body/tei:text/tei:div/tei:div[@n=\"$1\"]/tei:div[@n=\"$2\"])\"><tei:p>This pointer pattern extracts chapter</tei:p></tei:cRefPattern>"
     )
     a = Citation()
     self.assertEqual(str(a), "")

 def __init__(self, resource):
     self.base = str(resource.value(COIN.base))
     self.fragmentSeparator = str(resource.value(COIN.fragmentSeparator))
     self.slugTransform = SlugTransformer(resource.value(COIN.slugTransform))
     self.templates = [Template(self, template_resource)
                       for template_resource in resource.objects(
                               COIN.template)]
     # primary sort order by :priority
     # secondary sort by type specificity (wether a self.forType is specified)
     # tertiary sort order by specificity (number of vars per template)
     self.templates.sort(key=lambda x: (x.priority, x.forType, len(x.bindings)),
                         reverse=True) 

 def test_run_revsort(self):
     outDir = self._createTempDir()
     self._tester('src/toil/test/cwl/revsort.cwl',
                  'src/toil/test/cwl/revsort-job.json',
                  outDir, {
         # Having unicode string literals isn't necessary for the assertion but makes for a
         # less noisy diff in case the assertion fails.
         u'output': {
             u'location': "file://" + str(os.path.join(outDir, 'output.txt')),
             u'basename': str("output.txt"),
             u'size': 1111,
             u'class': u'File',
             u'checksum': u'sha1$b9214658cc453331b62c2282b772a5c063dbd284'}})

def test_particle():
    assert str(Eun) == u'은(는)'
    assert str(Eul) == u'을(를)'
    assert str(Ida) == u'(이)'
    if PY2:
        try:
            __import__('unidecode')
        except ImportError:
            assert repr(Ida) == u"<Particle: u'(\\uc774)'>"
        else:
            assert repr(Ida) == u'<Particle: (i)>'
    else:
        assert repr(Ida) == u'<Particle: (이)>'

    def test_get_parent(self):
        a = Reference("1.1")
        b = Reference("1")
        c = Reference("1.1-2.3")
        d = Reference("1.1-1.2")
        e = Reference("[email protected][0][email protected][2]")
        f = Reference("1-2")

        self.assertEqual(str(a.parent), "1")
        self.assertEqual(b.parent, None)
        self.assertEqual(str(c.parent), "1-2")
        self.assertEqual(str(d.parent), "1")
        self.assertEqual(str(e.parent), "[email protected][0][email protected][2]")
        self.assertEqual(f.parent, None)