/**
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package org.waveprotocol.wave.client.wavepanel.impl.edit;
import junit.framework.TestCase;
import org.waveprotocol.wave.model.document.MutableDocument;
import org.waveprotocol.wave.model.document.operation.automaton.DocumentSchema;
import org.waveprotocol.wave.model.document.raw.impl.Element;
import org.waveprotocol.wave.model.document.raw.impl.Node;
import org.waveprotocol.wave.model.document.raw.impl.Text;
import org.waveprotocol.wave.model.document.util.ContextProviders;
import org.waveprotocol.wave.model.document.util.ContextProviders.TestDocumentContext;
import org.waveprotocol.wave.model.document.util.DocHelper;
import org.waveprotocol.wave.model.document.util.LineContainers;
import org.waveprotocol.wave.model.document.util.PersistentContent;
import org.waveprotocol.wave.model.document.util.Point;
import org.waveprotocol.wave.model.document.util.PointRange;
import java.util.Collections;
/**
* Tests for {@link DocumentUtil}.
*/
public class DocumentUtilTest extends TestCase {
{
LineContainers.setTopLevelContainerTagname("body");
}
TestDocumentContext<Node, Element, Text> cxt;
MutableDocument<Node, Element, Text> doc;
private class TestState {
{
getDocWithoutSchema("<body><line id=\"alpha\"/>alpha<line id=\"beta\"/>beta"
+ "<line id=\"empty\"/><line id=\"gamma\"/>gamma</body>");
}
// Get <line/> elements
Element alphaLine = DocHelper.findElementById(doc, "alpha");
Element betaLine = DocHelper.findElementById(doc, "beta");
Element emptyLine = DocHelper.findElementById(doc, "empty");
Element gammaLine = DocHelper.findElementById(doc, "gamma");
// Get text nodes
Node alpha = alphaLine.getNextSibling();
Node beta = betaLine.getNextSibling();
Node gamma = gammaLine.getNextSibling();
// Wrap each line in <l:p> elements
Element alphaLp = wrapInLp(alpha, betaLine);
Element betaLp = wrapInLp(beta, emptyLine);
Element emptyLp = insertLp(gammaLine);
Element gammaLp = wrapInLp(gamma, null);
// Get various points for tests
Point<Node> startAlpha = Point.inText(alpha, 0);
Point<Node> inAlpha = Point.inText(alpha, 2);
Point<Node> endAlpha = Point.textOrElementEnd(cxt.annotatableContent(), alpha);
Point<Node> beforeBeta = Point.start(cxt.annotatableContent(), betaLp);
Point<Node> startBeta = Point.inText(beta, 0);
Point<Node> inBeta = Point.inText(beta, 2);
Point<Node> endBeta = Point.textOrElementEnd(cxt.annotatableContent(), beta);
Point<Node> inEmpty = Point.start(cxt.annotatableContent(), emptyLp);
Point<Node> beforeGamma = Point.start(cxt.annotatableContent(), gammaLp);
Point<Node> startGamma = Point.inText(gamma, 0);
Point<Node> inGamma = Point.inText(gamma, 2);
Point<Node> endGamma = Point.textOrElementEnd(cxt.annotatableContent(), gamma);
{
PersistentContent.makeHard(cxt.elementManager(), alphaLp);
}
}
/**
* A single test case for getBoundaryPointNearSelection with proper selection
* range
*
* @param startSelection beginning of selection
* @param endSelection end of selection
* @param correct the correct answer
*/
private void testGetBoundaryPointNearSelectionRange(
Point<Node> startSelection, Point<Node> endSelection, Point<Node> correct) {
int location = DocumentUtil.<Node, Element, Text> getLocationNearSelection(
doc, cxt.hardView(), new PointRange<Node>(startSelection, endSelection));
assertEquals(location, DocHelper.getFilteredLocation(doc, cxt.persistentView(), correct));
}
/**
* A single test case for getBoundaryPointNearSelection with collapsed
* selection
*
* @param caret collapsed section
* @param correct the correct answer
*/
private void testGetBoundaryPointNearSelectionPoint(Point<Node> caret, Point<Node> correct) {
int location =
DocumentUtil.getLocationNearSelection(doc, cxt.hardView(), new PointRange<Node>(caret));
assertEquals(location, DocHelper.getFilteredLocation(doc, cxt.persistentView(), correct));
}
public void testGetBoundaryPointNearSelectionRange() {
TestState s = new TestState();
testGetBoundaryPointNearSelectionRange(s.startAlpha, s.endAlpha, s.endAlpha);
testGetBoundaryPointNearSelectionRange(s.startAlpha, s.inAlpha, s.endAlpha);
testGetBoundaryPointNearSelectionRange(s.inAlpha, s.endAlpha, s.endAlpha);
// see http://b/issue?id=2059680
testGetBoundaryPointNearSelectionRange(s.startAlpha, s.beforeBeta, s.endAlpha);
testGetBoundaryPointNearSelectionRange(s.inAlpha, s.beforeBeta, s.endAlpha);
testGetBoundaryPointNearSelectionRange(s.endAlpha, s.beforeBeta, s.endAlpha);
testGetBoundaryPointNearSelectionRange(s.startBeta, s.endBeta, s.endBeta);
testGetBoundaryPointNearSelectionRange(s.startBeta, s.inBeta, s.endBeta);
testGetBoundaryPointNearSelectionRange(s.startBeta, s.inEmpty, s.endBeta);
testGetBoundaryPointNearSelectionRange(s.endBeta, s.inEmpty, s.endBeta);
testGetBoundaryPointNearSelectionRange(s.inBeta, s.inEmpty, s.endBeta);
testGetBoundaryPointNearSelectionRange(s.inEmpty, s.beforeGamma, s.inEmpty);
testGetBoundaryPointNearSelectionRange(s.startGamma, s.endGamma, s.endGamma);
testGetBoundaryPointNearSelectionRange(s.startGamma, s.inGamma, s.endGamma);
testGetBoundaryPointNearSelectionRange(s.inGamma, s.endGamma, s.endGamma);
}
public void testGetBoundaryPointNearSelectionPoint() {
TestState s = new TestState();
testGetBoundaryPointNearSelectionPoint(s.startAlpha, s.endAlpha);
testGetBoundaryPointNearSelectionPoint(s.inAlpha, s.endAlpha);
testGetBoundaryPointNearSelectionPoint(s.endAlpha, s.endAlpha);
testGetBoundaryPointNearSelectionPoint(s.startBeta, s.endBeta);
testGetBoundaryPointNearSelectionPoint(s.inBeta, s.endBeta);
testGetBoundaryPointNearSelectionPoint(s.endBeta, s.endBeta);
testGetBoundaryPointNearSelectionPoint(s.inEmpty, s.inEmpty);
testGetBoundaryPointNearSelectionPoint(s.startGamma, s.endGamma);
testGetBoundaryPointNearSelectionPoint(s.inGamma, s.endGamma);
testGetBoundaryPointNearSelectionPoint(s.endGamma, s.endGamma);
}
private Element insertLp(Node nodeAfter) {
return cxt.annotatableContent().transparentCreate("l:p",
Collections.<String, String> emptyMap(),
cxt.annotatableContent().getParentElement(nodeAfter), nodeAfter);
}
private Element wrapInLp(Node fromIncl, Node toExcl) {
Element lp = insertLp(fromIncl);
cxt.annotatableContent().transparentMove(lp, fromIncl, toExcl, null);
return lp;
}
private MutableDocument<Node, Element, Text> getDocWithoutSchema(String innerXml) {
cxt = ContextProviders.createTestPojoContext(
innerXml, null, null, null, DocumentSchema.NO_SCHEMA_CONSTRAINTS);
return doc = cxt.document();
}
}