使用 JUnit 测试 FindReplaceDocumentAdapter

最新推荐文章于 2024-10-10 21:35:31 发布
最新推荐文章于 2024-10-10 21:35:31 发布
阅读量1.2k 收藏
点赞数
分类专栏： Eclipse Plugin 文章标签： junit 测试 exception string unix class 
package org.eclipse.text.tests;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import java.util.Arrays;
import java.util.regex.PatternSyntaxException;
import ch.unibe.jexample.Given;
import ch.unibe.jexample.JExample;
import ch.unibe.jexample.JExampleOptions;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.eclipse.jface.text.BadLocationException;
import org.eclipse.jface.text.Document;
import org.eclipse.jface.text.FindReplaceDocumentAdapter;
import org.eclipse.jface.text.IRegion;
import org.eclipse.jface.text.Region;

@RunWith(JExample.class)
@JExampleOptions(cloneTestCase = true)
public class FindReplaceDocumentAdapterTestJUnit4JExample {
    
    @Test()
    public Document setUp() {
        Document fDocument = new Document();
        String text;
        text = "package TestPackage;\n/*\n* comment\n*/\n\tpublic class Class {\n\t\t// comment1\n\t\tpublic void method1() {\n\t\t}\n\t\t// comment2\n\t\tpublic void method2() {\n\t\t}\n\t}\n// Gel枚st";
        fDocument.set(text);
        return fDocument;
    }
    
    @Test()
    @Given("#testFindCaretInMiddleOfWord;#testRegexFindLinebreak2_fail;#testIllegalState;#testRegexReplace2;#testFindCaretAtEndStart;#testRegexReplace3;#testUTF8Pattern;#testFindCaretAtWordStart;#testRegexFindLinebreakIllegal;#testRegexFindStackOverflow_fail;#testRegexFindLinebreak;#testReplace;#testBug74993;#testFind;#testRegexRetainCase;#testRegexFindLinebreak3")
    public Document tearDown(Document fDocument) {
        fDocument = null;
        return fDocument;
    }
    
    @Test()
    @Given("#setUp")
    public Document testFind(Document fDocument) {
        FindReplaceDocumentAdapter findReplaceDocumentAdapter = new FindReplaceDocumentAdapter(fDocument);
        try {
            IRegion result = new Region(8, 11);
            IRegion r = findReplaceDocumentAdapter.find(0, "TestPackage", true, true, false, false);
            assertEquals(result, r);
            r = findReplaceDocumentAdapter.find(0, "testpackage", true, true, false, false);
            assertNull(r);
            r = findReplaceDocumentAdapter.find(0, "TestPackage", true, false, false, false);
            assertEquals(r, result);
            r = findReplaceDocumentAdapter.find(0, "testpackage", true, false, false, false);
            assertEquals(r, result);
        } catch (BadLocationException e) {
            Assert.assertTrue(false);
        }
        return fDocument;
    }
    
    @Test()
    @Given("#setUp")
    public Document testFindCaretInMiddleOfWord(Document fDocument) {
        FindReplaceDocumentAdapter findReplaceDocumentAdapter = new FindReplaceDocumentAdapter(fDocument);
        try {
            IRegion r = findReplaceDocumentAdapter.find(12, "TestPackage", true, false, false, false);
            assertNull(r);
            r = findReplaceDocumentAdapter.find(12, "TestPackage", false, false, false, false);
            assertNull(r);
        } catch (BadLocationException e) {
            Assert.assertTrue(false);
        }
        return fDocument;
    }
    
    @Test()
    @Given("#setUp")
    public Document testFindCaretAtWordStart(Document fDocument) {
        FindReplaceDocumentAdapter findReplaceDocumentAdapter = new FindReplaceDocumentAdapter(fDocument);
        try {
            IRegion r = findReplaceDocumentAdapter.find(8, "TestPackage", true, false, false, false);
            assertEquals(new Region(8, 11), r);
        } catch (BadLocationException e) {
            Assert.assertTrue(false);
        }
        return fDocument;
    }
    
    @Test()
    @Given("#setUp")
    public Document testFindCaretAtEndStart(Document fDocument) {
        FindReplaceDocumentAdapter findReplaceDocumentAdapter = new FindReplaceDocumentAdapter(fDocument);
        try {
            IRegion r = findReplaceDocumentAdapter.find(19, "TestPackage", false, false, false, false);
            assertEquals(new Region(8, 11), r);
        } catch (BadLocationException e) {
            Assert.assertTrue(false);
        }
        return fDocument;
    }
    
    @Test()
    @Given("#setUp")
    public Document testBug74993(Document fDocument) {
        FindReplaceDocumentAdapter findReplaceDocumentAdapter = new FindReplaceDocumentAdapter(fDocument);
        try {
            IRegion r = findReplaceDocumentAdapter.find(12, "\\w+", false, false, false, true);
            assertEquals(new Region(6, 1), r);
        } catch (BadLocationException e) {
            Assert.assertTrue(false);
        }
        return fDocument;
    }
    
    @Test()
    @Given("#setUp")
    public Document testUTF8Pattern(Document fDocument) {
        FindReplaceDocumentAdapter findReplaceDocumentAdapter = new FindReplaceDocumentAdapter(fDocument);
        try {
            IRegion result = new Region(153, 6);
            IRegion r = findReplaceDocumentAdapter.find(0, "Gel枚st", true, true, false, false);
            assertEquals(result, r);
            r = findReplaceDocumentAdapter.find(0, "Gel枚st", true, true, false, false);
            assertEquals(result, r);
            r = findReplaceDocumentAdapter.find(0, "Gel脰st", true, false, false, false);
            assertEquals(result, r);
            r = findReplaceDocumentAdapter.find(0, "Gel脰st", true, false, false, false);
            assertEquals(result, r);
        } catch (BadLocationException e) {
            Assert.assertTrue(false);
        }
        return fDocument;
    }
    
    @Test()
    @Given("#setUp")
    public Document testReplace(Document fDocument) {
        FindReplaceDocumentAdapter findReplaceDocumentAdapter = new FindReplaceDocumentAdapter(fDocument);
        try {
            findReplaceDocumentAdapter.find(0, "public", true, true, false, false);
            IRegion r = findReplaceDocumentAdapter.replace("private", false);
            assertNotNull(r);
            findReplaceDocumentAdapter.find(0, "public", true, true, false, false);
            r = findReplaceDocumentAdapter.replace("private", false);
            assertNotNull(r);
            findReplaceDocumentAdapter.find(0, "public", true, true, false, false);
            r = findReplaceDocumentAdapter.replace("private", false);
            assertNotNull(r);
            findReplaceDocumentAdapter.find(0, "public", true, true, false, false);
            try {
                findReplaceDocumentAdapter.replace("private", false);
            } catch (IllegalStateException e) {
                assertTrue(true);
            }
            String text = "package TestPackage;\n/*\n* comment\n*/\n\tprivate class Class {\n\t\t// comment1\n\t\tprivate void method1() {\n\t\t}\n\t\t// comment2\n\t\tprivate void method2() {\n\t\t}\n\t}\n// Gel枚st";
            assertEquals(text, fDocument.get());
        } catch (BadLocationException e) {
            Assert.assertTrue(false);
        }
        return fDocument;
    }
    
    public void _testRegexReplace(Document fDocument) throws Exception {
        fDocument.set("UnixWindowsMacInferred\nChars");
        FindReplaceDocumentAdapter findReplaceDocumentAdapter = new FindReplaceDocumentAdapter(fDocument);
        regexReplace("Unix", "$0\\n", findReplaceDocumentAdapter);
        regexReplace("(Windows)", "$1\\r\\n", findReplaceDocumentAdapter);
        regexReplace("(M)ac", "\\0\\r", findReplaceDocumentAdapter);
        regexReplace("(Inferred)", "\\1\\R", findReplaceDocumentAdapter);
        regexReplace("Chars", "\\\\, \\xF6, \\u00F6, \\t, \\n, \\r, \\f, \\a, \\e, \\cF", findReplaceDocumentAdapter);
        String text = "Unix\nWindows\r\nMac\rInferred\n\n\\, 枚, 枚, \t, \n, \r, \f, \007, \033, \006";
        assertEquals(text, fDocument.get());
    }
    
    @Test()
    @Given("#setUp")
    public Document testRegexReplace2(Document fDocument) throws Exception {
        FindReplaceDocumentAdapter findReplaceDocumentAdapter = new FindReplaceDocumentAdapter(fDocument);
        fDocument.set("foo");
        regexReplace("foo", "\\00", findReplaceDocumentAdapter);
        assertEquals("foo0", fDocument.get());
        fDocument.set("foo");
        regexReplace("foo", "\\010", findReplaceDocumentAdapter);
        assertEquals("foo10", fDocument.get());
        fDocument.set("foo");
        regexReplace("foo", "$00", findReplaceDocumentAdapter);
        assertEquals("foo0", fDocument.get());
        fDocument.set("foo");
        regexReplace("foo", "$010", findReplaceDocumentAdapter);
        assertEquals("foo10", fDocument.get());
        return fDocument;
    }
    
    @Test()
    @Given("#setUp")
    public Document testRegexReplace3(Document fDocument) throws Exception {
        FindReplaceDocumentAdapter findReplaceDocumentAdapter = new FindReplaceDocumentAdapter(fDocument);
        fDocument.set("foo");
        regexReplace("(f)oo", "\\10", findReplaceDocumentAdapter);
        assertEquals("f0", fDocument.get());
        fDocument.set("foo");
        regexReplace("(f)oo", "$10", findReplaceDocumentAdapter);
        assertEquals("f0", fDocument.get());
        return fDocument;
    }
    
    @Test()
    @Given("#setUp")
    public Document testRegexRetainCase(Document fDocument) throws Exception {
        FindReplaceDocumentAdapter findReplaceDocumentAdapter = new FindReplaceDocumentAdapter(fDocument);
        fDocument.set("foo");
        regexReplace("foo", "xyz\\Cbar\\Cfar", findReplaceDocumentAdapter);
        assertEquals("xyzbarfar", fDocument.get());
        fDocument.set("FOO");
        regexReplace("FOO", "xyz\\Cbar\\Cfar", findReplaceDocumentAdapter);
        assertEquals("xyzBARFAR", fDocument.get());
        fDocument.set("Foo");
        regexReplace("Foo", "xyz\\Cbar\\Cfar", findReplaceDocumentAdapter);
        assertEquals("xyzBarFar", fDocument.get());
        fDocument.set("Foox");
        regexReplace("F(oo)x", "\\C$1", findReplaceDocumentAdapter);
        assertEquals("oo", fDocument.get());
        fDocument.set("Foo");
        regexReplace("Foo", "xyz\\Cna\\u00EFve\\xFF\\C\\xFF", findReplaceDocumentAdapter);
        assertEquals("xyzNa茂ve每\u0178", fDocument.get());
        fDocument.set("FOO");
        regexReplace("FOO", "xyz\\Cna\\u00EFve\\xFF", findReplaceDocumentAdapter);
        assertEquals("xyzNA脧VE\u0178", fDocument.get());
        return fDocument;
    }
    
    private void regexReplace(String find, String replace, FindReplaceDocumentAdapter findReplaceDocumentAdapter) throws BadLocationException {
        findReplaceDocumentAdapter.find(0, find, true, true, false, true);
        IRegion r = findReplaceDocumentAdapter.replace(replace, true);
        assertNotNull(r);
    }
    
    @Test()
    @Given("#setUp")
    public Document testRegexFindLinebreak(Document fDocument) throws Exception {
        FindReplaceDocumentAdapter adapter = new FindReplaceDocumentAdapter(fDocument);
        String contents = "Unix\nWindows\r\nMac\rEnd";
        fDocument.set(contents);
        int n = contents.indexOf("\n");
        int rn = contents.indexOf("\r\n");
        int r = contents.indexOf("\rEnd");
        IRegion region = adapter.find(0, "\\R", true, false, false, true);
        assertEquals(new Region(n, 1), region);
        region = adapter.find(n + 1, "\\R", true, false, false, true);
        assertEquals(new Region(rn, 2), region);
        region = adapter.find(rn + 2, "\\R", true, false, false, true);
        assertEquals(new Region(r, 1), region);
        region = adapter.find(r + 1, "\\R", true, false, false, true);
        assertNull(region);
        return fDocument;
    }
    
    @Test()
    @Given("#setUp")
    public Document testRegexFindLinebreak2_fail(Document fDocument) throws Exception {
        FindReplaceDocumentAdapter adapter = new FindReplaceDocumentAdapter(fDocument);
        String contents = "Unix\n[\\R]\\R\r\n";
        fDocument.set(contents);
        int n = contents.indexOf("\n");
        int rn = contents.indexOf("\r\n");
        IRegion region = adapter.find(0, "[a-zA-Z\\t{\\\\R}]*\\{?\\R", true, false, false, true);
        assertEquals(new Region(0, n + 1), region);
        region = adapter.find(n + 1, "\\Q[\\R]\\R\\E{0,1}(\\R)", true, false, false, true);
        assertEquals(new Region(n + 1, rn + 2 - (n + 1)), region);
        try {
            adapter.replace("Win\\1$1", true);
        } catch (PatternSyntaxException ex) {
            return fDocument;
        }
        fail();
        return fDocument;
    }
    
    public void _testRegexFindLinebreak2(Document fDocument) throws Exception {
        FindReplaceDocumentAdapter adapter = new FindReplaceDocumentAdapter(fDocument);
        String contents = "+[\\R]\\R\r\n";
        fDocument.set(contents);
        int n = contents.indexOf("[");
        int rn = contents.indexOf("\r\n");
        IRegion region = adapter.find(0, "[a-zA-Z\\t{\\\\R}]*\\{?\\R", true, false, false, true);
        assertEquals(new Region(0, n - 1), region);
        region = adapter.find(n, "\\Q[\\R]\\R\\E{0,1}(\\R)", true, false, false, true);
        assertEquals(new Region(n, rn + 2 - n), region);
        adapter.replace("Win\\1$1", true);
        assertEquals("+Win\r\n\r\n", fDocument.get());
    }
    
    @Test()
    @Given("#setUp")
    public Document testRegexFindLinebreak3(Document fDocument) throws Exception {
        FindReplaceDocumentAdapter adapter = new FindReplaceDocumentAdapter(fDocument);
        String contents = "One\r\nTwo\r\n\r\nEnd";
        fDocument.set(contents);
        int two = contents.indexOf("Two");
        int end = contents.indexOf("End");
        IRegion region = adapter.find(0, "[a-zA-Z]+\\R", true, false, false, true);
        assertEquals(new Region(0, two), region);
        region = adapter.find(two, "[a-zA-Z]+\\R", true, false, false, true);
        assertEquals(new Region(two, 3 + 2), region);
        region = adapter.find(0, "[a-zA-Z]+\\R{2}", true, false, false, true);
        assertEquals(new Region(two, end - two), region);
        return fDocument;
    }
    
    @Test()
    @Given("#setUp")
    public Document testRegexFindLinebreakIllegal(Document fDocument) throws Exception {
        FindReplaceDocumentAdapter adapter = new FindReplaceDocumentAdapter(fDocument);
        fDocument.set("\n");
        IRegion region = null;
        try {
            region = adapter.find(0, "[\\R]", true, false, false, true);
        } catch (PatternSyntaxException e) {
        }
        assertNull(region);
        try {
            region = adapter.find(0, "[\\s&&[^\\R]]", true, false, false, true);
        } catch (PatternSyntaxException e) {
        }
        assertNull(region);
        try {
            region = adapter.find(0, "\\p{\\R}", true, false, false, true);
        } catch (PatternSyntaxException e) {
        }
        assertNull(region);
        return fDocument;
    }
    
    @Test()
    @Given("#setUp")
    public Document testIllegalState(Document fDocument) {
        FindReplaceDocumentAdapter findReplaceDocumentAdapter = new FindReplaceDocumentAdapter(fDocument);
        try {
            findReplaceDocumentAdapter.replace("TestPackage", false);
        } catch (IllegalStateException e) {
            Assert.assertTrue(true);
        } catch (BadLocationException e) {
            Assert.assertTrue(false);
        }
        findReplaceDocumentAdapter = new FindReplaceDocumentAdapter(fDocument);
        try {
            findReplaceDocumentAdapter.replace("TestPackage", true);
        } catch (IllegalStateException e) {
            Assert.assertTrue(true);
        } catch (BadLocationException e) {
            Assert.assertTrue(false);
        }
        return fDocument;
    }
    
    @Test()
    @Given("#setUp")
    public Document testRegexFindStackOverflow_fail(Document fDocument) throws Exception {
        FindReplaceDocumentAdapter adapter = new FindReplaceDocumentAdapter(fDocument);
        int len = 100000;
        char[] chars = new char[len];
        Arrays.fill(chars, '\n');
        chars[0] = '{';
        chars[len - 1] = '}';
        fDocument.set(new String(chars));
        try {
            adapter.find(0, "\\{(.|[\\r\\n])*\\}", true, false, false, true);
        } catch (PatternSyntaxException ex) {
            return fDocument;
        }
        fail();
        return fDocument;
    }
}

注：本文转载自：

https://www.iam.unibe.ch/scg/svn_repos/Students/haense/CaseStudies/org.eclipse.text.tests/jexample/org/eclipse/text/tests/FindReplaceDocumentAdapterTestJUnit4JExample.java

DavidHsing
关注
专栏目录
超级详细的Junit单元测试教程
奈何的人生
05-31 10万+
如果你只会使用@Test来完成单元测试，那你是时候该深入一下了，其实知识点一点都不少！
UnitTest:使用 Junit 进行单元测试
07-11
在深入讲解如何使用 JUnit 进行单元测试之前，我们先理解一下单元测试的基本概念。单元测试是对程序中最小可测试单元进行检查和验证，通常这个单元是函数、方法或类。通过单元测试，我们可以确保代码的正确性，减少...
junit 测试似有方法_关于junit：Java单元测试：替换测试中的私有方法
weixin_30521175的博客
01-14 443
在运行JUnit测试时，有没有办法在私有方法中替换逻辑？一些背景知识：我们有一些私有方法可以与OSGi容器中的bundle进行交互。 这在单元测试中不可用，因此方法将失败。我们已经看过JMockIt但是方法替换功能似乎想要强制你替换类中相互调用的所有方法。实现将是这样的：public final doSomething() {firstThing();secondThing();}private ...
replace与replaceAll的区别
热门推荐
鹏霄万里展雄飞
05-28 7万+
这两者有些人很容易搞混，因此我在这里详细讲述下。 replace的参数是char和CharSequence，即可以支持字符的替换，也支持字符串的替换（CharSequence即字符串序列的意思,说白了也就是字符串）； replaceAll的参数是regex，即基于规则表达式的替换，比如：可以通过replaceAll("\\d", "*")把一个字符串所有的数字字符都换成星号； 相同点：都
关于Android打印技术的调研—如何实现PrintAdapter？
太书红叶的博客
08-18 4262
杂谈—例行墨迹本来还在复（xue）习（xi）数据结构，然后好好的找一个好工作，但谁知还没等你复（yu）习（xi），就赶上了返校做毕设，写论文。于是一路狂风带闪电的毕业了，然后回北京找工作，一路狂风带闪电的投简历面试，最后没钱了，有一家录取我了，我就先来了。呵呵，没想到是搞医疗的，虽然也是Android但是有些不爽啊，和我想像的做app根本不一样，而且还有入职培训—长达一个月！！！！！！！！！！是不是
如何在JUnit 5中替换规则
最佳 Java 编程
06-01 314
最近发布的JUnit 5（又名JUnit Lambda） Alpha发行版引起了我的兴趣，在浏览文档时，我注意到规则以及赛跑者规则和类规则都消失了。 根据文档，这些部分竞争的概念已被单个一致的扩展模型取代。 多年来， Frank和我写了一些规则来帮助执行重复性任务，例如测试SWT UI ， 忽略某些环境中的测试 ， 注册（测试）OSGi服务 ， 在单独的线程中运行测试等等。 因此，我...
idea中使用JUnit单元测试
s39484884的博客
12-16 1344
idea中使用JUnit单元测试
Junit 进行单元测试
yyp0719的博客
04-28 3888
单元测试（unit testing），是指对软件中的最小可测试单元进行检查和验证。“单元”可以是一个函数、方法、类、功能模块或者子系统。单元测试的核心在于行、分支覆盖率，不关注业务正确性。
IDEA中使用Junit测试
qq_47895373的博客
06-19 4062
IDEA中Maven框架中使用JUnit进行测试
SpringBoot中使用Junit测试
dayuiicghaid的博客
04-12 1万+
SpringBoot中使用Junit测试
单元测试实战-Junit测试
01-27
Junit是Java语言中最广泛使用的单元测试框架，它简化了测试代码的编写和执行。本文将深入探讨如何进行单元测试实战，特别是使用Junit进行测试。 首先，单元测试的基础是创建被测单元的实例并调用其方法。在没有...
FreeSWITCH 分机网关路由
fs交流的博客
10-09 98
分机网关路由应该来自 FusionPBX。可以参考下面这个 api。
Lua正则表达式（模式匹配规则）-提取颜色/
最新发布
hookby的专栏
10-10 94
文字
selenium自动化测试之Junit
2202_76101487的博客
10-10 385
本文主要写了selenium测试中相关的junit测试部分的操作；
Spring MVC的运行流程详解
J老熊
10-03 1033
Spring MVC作为一个广泛使用的框架，提供了灵活且强大的MVC架构支持。尤其在业务系统中，Spring MVC能够有效地处理大量并发请求，提供良好的用户体验。本文将详细讲解Spring MVC的运行流程，以电商交易系统为案例，帮助读者深入理解其工作原理。
单元测试规则：使用JUnit测试性能调优工具
"使用JUnit对规则进行单元测试的实践指南" 在单元测试中，规则（Rule）是一个重要的概念，它允许我们控制测试执行时的行为，比如在测试前后执行特定的操作或者自定义测试环境。JUnit是Java中最常用的单元测试框架，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值