qileilove

blog已经转移至github,大家请访问 http://qaseven.github.io/

Android自动化测试生成单元测试结果报告

　　使用robotium进行Android应用进行自动化测试，之前用TMTS框架，但收集到的单元测试结果常常会少掉一些用例集。。穷则思变，Android的测试框架主要是通过InstrumentationTestRunner对被测应用进行控制与执行，因此可以对InstrumentationTestRunner进行扩展以完成测试结果收集，然后通过jenkins的Publish JUnit test result report插件得到结果报告。
　　1.新建一个java package，新建一个java类
　　源码来自开源项目：https://code.google.com/p/nbandroid-utils/
　　源码中生成的TEST-all.xml结果文件位于/data/data/com.example/files目录下，要导出结果文件的话，需要手机拥有root权限，比较麻烦，因此下面修改了文件存放路径，有SD卡则文件位于SD卡的/robotium目录下
package com.example.test.instrumentation;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;
import org.xmlpull.v1.XmlPullParserFactory;
import org.xmlpull.v1.XmlSerializer;
import android.content.Context;
import android.os.Bundle;
import android.os.Environment;
/**
* This test runner creates a TEST-all.xml in the files directory of the application under test. The output is compatible with that of the junitreport ant task, the format
* that is understood by Hudson. Currently this implementation does not implement the all aspects of the junitreport format, but enough for Hudson to parse the test results.
*/
public class InstrumentationTestRunner extends android.test.InstrumentationTestRunner {
private Writer mWriter;
private XmlSerializer mTestSuiteSerializer;
private long mTestStarted;
private static final String JUNIT_XML_FILE = "TEST-all.xml";
@Override
public void onStart() {
try{
File fileRobo = new File(getTestResultDir(getTargetContext()));
if(!fileRobo.exists()){
fileRobo.mkdir();
}
if(isSDCardAvaliable()){
File resultFile = new File(getTestResultDir(getTargetContext()),JUNIT_XML_FILE);
startJUnitOutput(new FileWriter(resultFile));
}else{
startJUnitOutput(new FileWriter(new File(getTargetContext().getFilesDir(), JUNIT_XML_FILE)));
}
}
catch(IOException e){
throw new RuntimeException(e);
}
super.onStart();
}
void startJUnitOutput(Writer writer) {
try {
mWriter = writer;
mTestSuiteSerializer = newSerializer(mWriter);
mTestSuiteSerializer.startDocument(null, null);
mTestSuiteSerializer.startTag(null, "testsuites");
mTestSuiteSerializer.startTag(null, "testsuite");
} catch (Exception e) {
throw new RuntimeException(e);
}
}




    
/**
* 判断SD卡是否存在
* @return
*/
private boolean isSDCardAvaliable(){
return Environment.getExternalStorageState()
.equals(Environment.MEDIA_MOUNTED);
}
/**
* 获取测试结果报告文件所在的路径
* @param context  被测工程的context
* @return  返回测试结果报告文件所在的路径
*/
private String getTestResultDir(Context context){
String packageName = "/" + "robotium";
String filepath = context.getCacheDir().getPath() + packageName;
if(android.os.Build.VERSION.SDK_INT < 8){
if(isSDCardAvaliable()){
filepath = Environment.getExternalStorageDirectory().getAbsolutePath()+ packageName;
}
}else{
if(isSDCardAvaliable()){
filepath = Environment.getExternalStorageDirectory().getAbsolutePath()+ packageName;
}
}
return filepath;
}
private XmlSerializer newSerializer(Writer writer) {
try {
XmlPullParserFactory pf = XmlPullParserFactory.newInstance();
XmlSerializer serializer = pf.newSerializer();
serializer.setOutput(writer);
return serializer;
} catch (Exception e) {
throw new RuntimeException(e);
}
}
@Override
public void sendStatus(int resultCode, Bundle results) {
super.sendStatus(resultCode, results);
switch (resultCode) {
case REPORT_VALUE_RESULT_ERROR:
case REPORT_VALUE_RESULT_FAILURE:
case REPORT_VALUE_RESULT_OK:
try {
recordTestResult(resultCode, results);
} catch (IOException e) {
throw new RuntimeException(e);
}
break;
case REPORT_VALUE_RESULT_START:
recordTestStart(results);
default:
break;
}
}
void recordTestStart(Bundle results) {
mTestStarted = System.currentTimeMillis();
}
void recordTestResult(int resultCode, Bundle results) throws IOException {
float time = (System.currentTimeMillis() - mTestStarted) / 1000.0f;
String className = results.getString(REPORT_KEY_NAME_CLASS);
String testMethod = results.getString(REPORT_KEY_NAME_TEST);
String stack = results.getString(REPORT_KEY_STACK);
int current = results.getInt(REPORT_KEY_NUM_CURRENT);
int total = results.getInt(REPORT_KEY_NUM_TOTAL);
mTestSuiteSerializer.startTag(null, "testcase");
mTestSuiteSerializer.attribute(null, "classname", className);
mTestSuiteSerializer.attribute(null, "name", testMethod);
if (resultCode != REPORT_VALUE_RESULT_OK) {
mTestSuiteSerializer.startTag(null, "failure");
if (stack != null) {
String reason = stack.substring(0, stack.indexOf('\n'));
String message = "";
int index = reason.indexOf(':');
if (index > -1) {
message = reason.substring(index+1);
reason = reason.substring(0, index);
}
mTestSuiteSerializer.attribute(null, "message", message);
mTestSuiteSerializer.attribute(null, "type", reason);
mTestSuiteSerializer.text(stack);
}
mTestSuiteSerializer.endTag(null, "failure");
} else {
mTestSuiteSerializer.attribute(null, "time", String.format("%.3f", time));
}
mTestSuiteSerializer.endTag(null, "testcase");
if (current == total) {
mTestSuiteSerializer.startTag(null, "system-out");
mTestSuiteSerializer.endTag(null, "system-out");
mTestSuiteSerializer.startTag(null, "system-err");
mTestSuiteSerializer.endTag(null, "system-err");
mTestSuiteSerializer.endTag(null, "testsuite");
mTestSuiteSerializer.flush();
}
}
@Override
public void finish(int resultCode, Bundle results) {
endTestSuites();
super.finish(resultCode, results);
}
void endTestSuites() {
try {
mTestSuiteSerializer.endTag(null, "testsuites");
mTestSuiteSerializer.endDocument();
mTestSuiteSerializer.flush();
mWriter.flush();
mWriter.close();
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}



　2.修改AndroidManifest.xml文件
　　将原来的：
<instrumentation
android:name="android.test.InstrumentationTestRunner"
android:targetPackage="com.example" />
　　修改为：
<instrumentation
android:name="com.example.test.instrumentation.InstrumentationTestRunner"
android:targetPackage="com.example" />
　　3.修改Run Configurations
　　右键测试工程>Run as >Run Configurations
　　在Test栏中，勾选Run all tests in the selected project,or package
　　这样每次在Eclipse中运行时才会使用新的InstrumentationTestRunner
　　在Instrumentation runner处下拉选择新写的InstrumentationTestRunner
　　点击Apply完成设置
　　4.命令行下运行测试用例
Running all tests: adb shell am instrument -w com.android.foo/com.example.test.instrumentation.InstrumentationTestRunner
Running a single testcase: adb shell am instrument -w -e class com.android.foo.FooTest com.android.foo/com.example.test.instrumentation.InstrumentationTestRunner
Running multiple tests: adb shell am instrument -w -e class com.android.foo.FooTest,com.android.foo.TooTest com.android.foo/com.example.test.instrumentation.InstrumentationTestRunner
　　命令行下运行测试用例与平时一样，只要将原来的InstrumentationTestRunner换成新的InstrumentationTestRunner就行，
　　需要注意的是，由于每次命令行执行完毕，都会覆盖原有的TEST-all.xml文件，即如果采用Running a single testcase方式运行多个测试用例集，则最后结果只会记录最后一个用例集，因此建议采用Running multiple tests方式
　　5.运行完成后将手机中的文件导出
　　adb -s $ANDROID_AVD_DEVICE pull /mnt/sdcard/rototium/TEST-all.xml
　　其中$ANDROID_AVD_DEVICE为参数化的手机序列号
　　6.在jenkins中任务构建完成后即可使用Publish JUnit test result report插件分析得出单元测试报告了

posted @ 2013-11-14 10:48 顺其自然EVO 阅读(491) | 评论 (0) | 编辑 收藏

单元测试Struts2Spring项目的Action和Service

　最近，认真实践了单元测试Struts2、Spring等Java项目，今天特意写的是单元测试Struts2Spring项目的Action和Service。
　　由于已经写过不少Web开发框架单元测试的代码，加上上次从头搭建环境并发表了"单元测试Struts2的Action（包含源码） ",没有遇到太多问题。
　　特别说明：本文是原创，搭建环境、写代码、运行，都是实践并且正确的。
　　本文是靠谱的，而非简单的复制-粘贴。
　　1.特别说明。
　　http://blog.csdn.net/fansunion/article/details/12118043  单元测试Struts2的Action（包含源码）
　　这篇文章主要讲述的是如何 使用JUnit等单元测试框架测试 Struts2这一个框架的Action。
　　而本篇侧重Struts2和Spring这2个框架集成的情况。
　　更多框架集成的单元测试Demo文章，请关注本博客后续 单元测试相关文章。
　　2.新建工程，加入相关jar包。
　　Struts相关jar包
　　Spring相关jar包
　　JUnit, spring-test-3.2.3.RELEASE.jar,struts2-junit-plugin-2.2.3.1.jar等测试相关jar包
　　Tomcat的Servlet/JSP jar包
　　3.新建Action。
package action;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
/**
* 一个简单的Action。
* @author FansUnion
*
*/
@Controller
public class UserAction {
@Autowired
private UserService userService;
public String getName() {
userService.getName("FansUnion");
return "success";
}
}


4.新建Service。
package action;
import org.springframework.stereotype.Service;
@Service
public class UserService {
/**
* 简单的返回用户名
*/
public String getName(String name) {
// 这个地方实际上应该调用Dao持久层的代码，在此简化了。
// 本文只是单元测试Struts2Spring整合中，Struts的Action和Spring注入的Service。
// Struts2Spring+Hibernate/Mybatis将在后续篇章中介绍。
return name;
}
}
　　5.单元测试Action。
package unittest;
import org.apache.struts2.StrutsSpringTestCase;
import org.junit.Test;
import action.UserAction;
import com.opensymphony.xwork2.ActionProxy;
/**
* 测试StrutsSpring集成的时候，需要继承StrutsSpringTestCase这个类，
* 而单独测试Struts的时候，继承StrutsTestCase。
*
* @author http://blog.csdn.net/fansunion/
*
*/
public class ActionUnitTest extends StrutsSpringTestCase {
// 重写父类方法,指定配置文件的名字
protected String[] getContextLocations() {
return new String[] { "struts.xml", "applicationContext-spring.xml" };
}
@Test
public void testExecute() throws Exception {
ActionProxy proxy = getActionProxy("/unitTest");
UserAction test = (UserAction) proxy.getAction();
assertNotNull(test);
String result = proxy.execute();
assertEquals("success", result);
}
}


4.新建Service。
package action;
import org.springframework.stereotype.Service;
@Service
public class UserService {
/**
* 简单的返回用户名
*/
public String getName(String name) {
// 这个地方实际上应该调用Dao持久层的代码，在此简化了。
// 本文只是单元测试Struts2Spring整合中，Struts的Action和Spring注入的Service。
// Struts2Spring+Hibernate/Mybatis将在后续篇章中介绍。
return name;
}
}
　　5.单元测试Action。
package unittest;
import org.apache.struts2.StrutsSpringTestCase;
import org.junit.Test;
import action.UserAction;
import com.opensymphony.xwork2.ActionProxy;
/**
* 测试StrutsSpring集成的时候，需要继承StrutsSpringTestCase这个类，
* 而单独测试Struts的时候，继承StrutsTestCase。
*
* @author http://blog.csdn.net/fansunion/
*
*/
public class ActionUnitTest extends StrutsSpringTestCase {
// 重写父类方法,指定配置文件的名字
protected String[] getContextLocations() {
return new String[] { "struts.xml", "applicationContext-spring.xml" };
}
@Test
public void testExecute() throws Exception {
ActionProxy proxy = getActionProxy("/unitTest");
UserAction test = (UserAction) proxy.getAction();
assertNotNull(test);
String result = proxy.execute();
assertEquals("success", result);
}
}


4.新建Service。
package action;
import org.springframework.stereotype.Service;
@Service
public class UserService {
/**
* 简单的返回用户名
*/
public String getName(String name) {
// 这个地方实际上应该调用Dao持久层的代码，在此简化了。
// 本文只是单元测试Struts2Spring整合中，Struts的Action和Spring注入的Service。
// Struts2Spring+Hibernate/Mybatis将在后续篇章中介绍。
return name;
}
}
　　5.单元测试Action。
package unittest;
import org.apache.struts2.StrutsSpringTestCase;
import org.junit.Test;
import action.UserAction;
import com.opensymphony.xwork2.ActionProxy;
/**
* 测试StrutsSpring集成的时候，需要继承StrutsSpringTestCase这个类，
* 而单独测试Struts的时候，继承StrutsTestCase。
*
* @author http://blog.csdn.net/fansunion/
*
*/
public class ActionUnitTest extends StrutsSpringTestCase {
// 重写父类方法,指定配置文件的名字
protected String[] getContextLocations() {
return new String[] { "struts.xml", "applicationContext-spring.xml" };
}
@Test
public void testExecute() throws Exception {
ActionProxy proxy = getActionProxy("/unitTest");
UserAction test = (UserAction) proxy.getAction();
assertNotNull(test);
String result = proxy.execute();
assertEquals("success", result);
}
}


　6.单元测试Service。
package unittest;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.springframework.mock.web.MockServletContext;
import org.springframework.web.context.WebApplicationContext;
import org.springframework.web.context.support.XmlWebApplicationContext;
/**
* 测试Service的基类
*
* @author http://blog.csdn.net/fansunion/
*
*/
public class JUnitTestBase {
public static XmlWebApplicationContext context = null;
public static String[] CONFIG_FILES = { "file:src/applicationContext-*.xml" };
public JUnitTestBase() {
System.out.println("JUnitTestBase");
}
@BeforeClass
public static void setUp() {
System.out.println("Test start…");
context = new XmlWebApplicationContext();
context.setConfigLocations(CONFIG_FILES);
MockServletContext msc = new MockServletContext();
context.setServletContext(msc);
context.refresh();
msc.setAttribute(
WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE,
context);
}
@AfterClass
public static void tearUp() {
System.out.println("Test end!");
}
}
package unittest;
import static org.junit.Assert.assertEquals;
import org.junit.Test;
import action.UserService;
public class UserServiceTest extends JUnitTestBase {
private UserService userService;
public UserServiceTest() {
userService = context.getBean(UserService.class);
}
@Test
public void test() {
String name = "http://FansUnion.cn";
String myName = userService.getName(name);
assertEquals(name, myName);
}
}
　　7.Struts2配置。
<struts>
<!– Development Mode –>
<constant name="struts.devMode" value="true" />
<constant name="struts.enable.DynamicMethodInvocation" value="false" />
<constant name="struts.objectFactory" value="spring" />
<constant name="struts.objectFactory.spring.autoWire" value="name" />
<package name="manager" namespace="/" extends="struts-default">
<action name="unitTest" class="userAction" method="getName">
<result name="success">unitTest.jsp
</result>
</action>
</package>
</struts>



字体:  小  中  大  | 上一篇 下一篇 | 打印  | 我要投稿 

　　8.Spring配置。
　　（由于是从我的就项目复制类的，很多配置都可以去掉，由读者自己完成）
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:flex="http://www.springframework.org/schema/flex" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-3.0.xsd
http://www.springframework.org/schema/flex
classpath:/spring-flex-1.0.xsd
">
<context:annotation-config />
<context:component-scan base-package="*" />
<aop:aspectj-autoproxy />
</beans>
　　9.web.xml配置。
<?xml version="1.0" encoding="UTF-8"?>
<web-app id="WebApp_ID" version="2.4"
xmlns="http://java.sun.com/xml/ns/j2ee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">
<!– Spring Context –>
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:/applicationContext*.xml</param-value>
</context-param>
<!– Spring Context Listener –>
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<filter>
<filter-name>struts2</filter-name>
<filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>
</filter>
<filter-mapping>
<filter-name>struts2</filter-name>
<url-pattern>*.action</url-pattern>
</filter-mapping>
</web-app>

posted @ 2013-11-14 10:38 顺其自然EVO 阅读(2843) | 评论 (0) | 编辑 收藏

JMeter入门(1)：JMeter总体介绍及组件介绍

一、JMeter概述
　　JMeter就是一个测试工具，相比于LoadRunner等测试工具，此工具免费，且比较好用，但是前提当然是安装Java环境；
　　JMeter可以做
　　(1)压力测试及性能测试；
　　(2)数据库测试；
　　(3)Java程序的测试；
　　(4)HTTP及FTP测试；
　　(5)Web Service测试；
　　等等；
　　和JMeter一起使用的可能是JDK自带的测试工具JConsole，位于JDK\bin\JConsole，此工具主要观察堆、JVM、CPU的使用情况，界面如下：
　　二、JMeter安装
　　解压缩即可；
　　JMeter插件：http://code.google.com/p/jmeter-plugins/downloads/detail?name=JMeterPlugins-0.5.3.zip
　　下载后将jar文件放到JMETER_HOME\lib\ext目录；

　三、JMeter常用组件
　　测试计划：整个测试计划；
　　线程组：所有的任务都是基于线程组，开通多少个线程就代表有多少个并发用户；
　　Ramp-Up Period：在这么多时间内完成全部测试，比如开了2个线程，而Ramp-Up Period为3，则每个线程的间隔为1.5秒；
　　Sampler：所有的测试任务都是Sampler，即任何测试任务的类别都是Sampler，比如HTTP请求、JDBC请求、FTP请求；
　　断言：对Sampler的测试进行判断是否正确；
　　监听器：对Sampler的请求结果进行统计、显示；
　　常用的层次结构为：
　　常用的组件有：
　　HTTP请求：模拟HTTP请求；
　　查看结果树：对于每个请求，可以查看HTTP请求和HTTP响应；
　　图形结果：可以图形显示吞吐量、响应时间等；
　　聚合报告：总体的吞吐量、响应时间；
　　1、Label： 定义的HTTP请求名称
　　2、Samples： 表示这次测试中一共发出了多少个请求
　　3、Average： 访问页面的平均响应时间
　　4、Min: 访问页面的最小响应时间
　　5、Max: 访问页面的最大响应时间
　　6、Error%： 错误的请求的数量/请求的总数
　　7、Throughput：每秒完成的请求数
　　8、KB/Sec： 每秒从服务器端接收到的数据量

posted @ 2013-11-14 10:33 顺其自然EVO 阅读(364) | 评论 (0) | 编辑 收藏

Java ArrayList用法入门

　ArrayList用法：
　　ArrayList是接口List的实现类，所以推荐以List接口来使用。
　　1、创建ArrayList的List接口
　　例：
　　List books = new ArrayList();
　　Java支持泛形后，创建的同时可以指定元素的类型。
　　例：
Class Book {
......
}
List<Book> books = new ArrayList<Book>();
　　为避免容器自动扩容的次数而影响性能，可以指定创建时的元素大小。
　　例： 创建可容纳100个Book对象的ArrayList，超过100个将自动扩容
　　List<Book> books = new ArrayList<Book>(100);
　　2、添加元素
　　添加在末尾
　　例：
Book book1 = new Book();
Book book2 = new Book();
Book book3 = new Book();
books.add(book1);
books.add(book2);
books.add(book3);
　　添加在指定索引处
　　例：
// 虽然加book1后直接加book3了，但book2是被加在索引1的地方
// 所以效果同上，是book1、book2、book3的顺序
books.add(book1);
books.add(book3);
books.add(1, book2);
　　3、 获取ArrayList中元素的个数
　　例：
　　int count = books.size();
　　4、读取元素
　　利用普通的for循环：
　　例：
for (int i = 0; i < books.size(); i++ {
Book newBook = books.get(i);
// 不带泛形的注意要转型
Book book = (Book) books.get(i);
System.out.println(book.getName());
}


　　利用for循环的新特性：
　　例：
for (Book book : books) {
// 用book就能访问了
System.out.println(book.getName());
}
　　利用枚举：
　　例：
Iterator<Book> iter = books.iterator();
while (iter.hasNext()) {
Book book = iter.next();
System.out.println(book.getName());
}
　　5、移除元素
　　移除指定索引处的元素
　　例：
books.remove(0); // 移除book1
books.remove(1); // 移除book2
books.remove(2); // 移除book3
　　移除指定对象的所在元素
　　例：
Book delBook = books.get(1);
books.remove(delBook); // 移除book2
　　移除所有元素
　　例：
　　books.clear();
　　6、判断ArrayList是否为空（没有元素）
　　原方法：
if (books.isEmpty()) {
}
　　直接判断大小：
if (books.size() == 0) {
}
　　7、判断ArrayList中是否已经存在了某对象
　　例：
　　// 判断是否已经存在book2对象
　　if (books.contains(book2)) { // 已经存在
　　}
　　8、根据对象反查询它的索引位置
　　从前住后查询，反回第一个符合条件的位置
　　例：
　　list.indexOf(book2); // 查询book2对象的索引位置
　　从后住前查询，反回第一个符合条件的位置
　　例：
　　list.lastIndexOf(book2); // 查询book2对象的索引位置
　　以上这些掌握后，基本就没问题了。

posted @ 2013-11-14 10:32 顺其自然EVO 阅读(240) | 评论 (0) | 编辑 收藏

jsp连接mysql数据库

　　主要代码:
<%@ page language="java" import="java.util.*,java.sql.*" pageEncoding="UTF-8"%>
<%
String driverClass="com.mysql.jdbc.Driver";
String url="jdbc:mysql://localhost:3306/news";
String username="root";
String password="";
Class.forName(driverClass);
Connection conn=DriverManager.getConnection(url,username,password);
Statement stat=conn.createStatement();
ResultSet rs=stat.executeQuery("select * from newdb");
%>
<%
while(rs.next()){
}
%>
<%
rs.close();
stat.close();
conn.close();
%>

posted @ 2013-11-14 10:28 顺其自然EVO 阅读(164) | 评论 (0) | 编辑 收藏

Oracle Database 10g 未在当前操作系统中经过认证

　　错误信息如下：
　　《提示有1个错误，1个警告，2个要求待验证 错误问题详细信息如下：正在检查操作系统要求… 要求的结果: 5.0,5.1,5.2,6.0 之一实际结果: 6.1 检查完成。此次检查的总体结果为: 失败 <<<< 问题: Oracle Database 10g 未在当前操作系统中经过认证。建议案: 确保在正确的平台上安装软件。
　　警告问题详细信息如下：正在检查网络配置要求… 检查完成。此次检查的总体结果为: 失败 <<<< 问题: 安装检测到系统的主 IP 地址是 DHCP 分配的地址。建议案: Oracle 支持在具有 DHCP 分配的 IP 地址的系统上进行安装。但在安装之前, 必须将 Microsoft LoopBack Adapter 配置为系统的主网络适配器。有关在配置有 DHCP 的系统上安装软件的详细信息, 请参阅 Installation Guide。
　　待验证问题详细信息如下：正在检查 Service Pack 要求… 检查完成。此次检查的总体结果为: 未执行 <<<< OUI-18001: 不支持操作系统 ‘Windows Vista 版本 6.1′。建议案: 请安装建议的 Service Pack。》
　　如果出现如上的信息那么就进行如下操作；【第一对IP进行静态绑定可以忽略。但第二部修改配置文件是必须的】
　　1、对电脑的IP地址进行静态邦定，不要自己动获取。
　　2、oracle不能够识别Windows 7 ，只需要修改refhost.xml文件，让Oracle能够识别到操作系统的类型。点击oracle安装文件，直接查找，因为oracle可能存在多个refhost.xml文件，每一个文件都需要修改。然后添加如下代码： <!–Microsoft Windows 7–> 添加位置参考refhost.xml文件中xp或者vista的问题。修改完Oracle下所有的refhost.xml文件后，点击安装。一路顺风，没有任何的问题了。
　　【在要安装包Oracle目录中搜索所有的“refhost.xml”的文件，然后在文件下 <CERTIFIED_SYSTEMS> 目录添加以下配置】
------------------------------------
<!--Microsoft Windows 7-->
<OPERATING_SYSTEM>
<VERSION VALUE="6.1"/>
</OPERATING_SYSTEM>
---------------------------------

posted @ 2013-11-14 10:18 顺其自然EVO 阅读(307) | 评论 (0) | 编辑 收藏

dbms_sqldiag 创建sql测试用例

　　你需要创建一个SQL测试用例，在另一台机器上重现SQL失败。可能是用来进行你自己的诊断，也可能是让oracle技术团队能够重现失败。
sys@ORCL> conn /as sysdba
已连接。
sys@ORCL> grant read,write on directory exp_dir to u2;
授权成功。
sys@ORCL> grant read,write on directory exp_dir to u1;
授权成功。
sys@ORCL> grant dba to u2;
sys@ORCL> grant dba to u1;
授权成功。
　　directory目录前面已经创建了，授权给用户u1、u2。而且用户u1、u2需要拥有dba权限。
sys@ORCL> conn u2/u2
已连接。
u2@ORCL> select count(*) from t;
COUNT(*)
----------
1
u2@ORCL> conn u1/u1
已连接。
u1@ORCL> select count(*) from t;
select count(*) from t
*
第 1 行出现错误:
ORA-00942: 表或视图不存在
　　可以看见u1下面是不可以执行t表的查询的，现在我们就把u2下面的这个sql用例导入到u1用户下。
导出：
u2@ORCL> conn u2/u2
已连接。
u2@ORCL> declare mycase clob;
2  begin
dbms_sqldiag.export_sql_testcase(directory => 'EXP_DIR',sql_text => 'select count(*) from t',user_name => 'U2',exportData => true,testcase => mycase);
4  end;
5  /
PL/SQL 过程已成功完成。

　可以看见directory目录多了很多东西：
[root@linux exp_dir]# ll
总计 248
-rw-r----- 1 oracle oinstall 196608 11-08 21:49 oratcb1_007D001B0001dpexp.dmp
-rw-r--r-- 1 oracle oinstall    969 11-08 21:49 oratcb1_007D001B0001dpexp.log
-rw-r--r-- 1 oracle oinstall   4563 11-08 21:48 oratcb1_007D001B0001dpexp.sql
-rw-r--r-- 1 oracle oinstall   3773 11-08 21:49 oratcb1_007D001B0001dpimp.sql
-rw-r--r-- 1 oracle oinstall   1763 11-08 21:49 oratcb1_007D001B0001main.xml
-rw-r--r-- 1 oracle oinstall    239 11-08 21:48 oratcb1_007D001B0001ol.xml
-rw-r--r-- 1 oracle oinstall    173 11-08 21:48 oratcb1_007D001B0001sql.xml
-rw-r--r-- 1 oracle oinstall    388 11-08 21:49 oratcb1_007D001B0001ssimp.sql
-rw-r--r-- 1 oracle oinstall    422 11-08 21:49 oratcb1_007D001B0001xplf.sql
-rw-r--r-- 1 oracle oinstall    654 11-08 21:49 oratcb1_007D001B0001xplo.sql
-rw-r--r-- 1 oracle oinstall    399 11-08 21:49 oratcb1_007D001B0001xpls.sql
-rw-r--r-- 1 oracle oinstall   1891 11-08 21:49 oratcb1_007D001B0001xpl.txt
-rw-r--r-- 1 oracle oinstall   2316 11-08 21:48 README.txt
　　导入：
u2@ORCL> conn u1/u1
已连接。
u1@ORCL> exec dbms_sqldiag.import_sql_testcase(directory => 'EXP_DIR',filename => 'oratcb1_007D001B0001main.xml',importData => true);
PL/SQL 过程已成功完成。
u1@ORCL> select count(*) from t
2  ;
COUNT(*)
----------
1
u1@ORCL> select * from t;
A
----------
1
u1@ORCL> select * from tab;
TNAME                          TABTYPE  CLUSTERID
------------------------------ ------- ----------
T                              TABLE

posted @ 2013-11-13 10:37 顺其自然EVO 阅读(213) | 评论 (0) | 编辑 收藏

性能测试项目实施流程

　经过一段时间的性能测试工作后，感觉有必要对自己的工作做一个总结，从总结中抽取共性的东西来形成一种规则与流程，这样可以更好地开展以后的工作，同时也希望工作中能更好地完善自我，不断地自我提升。以下是我在性能测试工作中总结出来的基本实施流程，也希望能得到看到此文章的大家的指点。
　　第一阶段，测试设计阶段
　　此阶段的工作有以下几项内容：
　　（1）拿到客户需求后，对被测系统的性能需求进行一个充分的理解与分析，并定义测试目标与范围，也就是确定需要进行性能测试的模块及功能点；
　　（2）了解被测系统的技术信息，比如系统架构是BS还是CS，确定协议；
　　（3）确定测试方案，并制定场景设置方案，另需要准备并收集测试使用数据。为方便管理，在收集数据时可制定数据收集模板，因为项目不同，需要收集的数据也不同；
　　（4）邀请项目相关人员进行测试方案的评审。
　　注意，最后一点是很有必要的，毕竟大家一起讨论出来的方案，比起一个人在那儿苦想要更快也更完备，而且对于可能遇到的问题也可通过讨论来解决。方案通过后，就可以进
　　入下一步了。
　　确定性能测试点的小技巧：
　　（1）重要的功能点；
　　（2）使用频繁的功能点；
　　（3）用户关心的功能点；
　　（4）与DB密切相关的点（比如，查询、浏览、保存、新增等，一般需要找出3-4个查询的点，1-2个提交数据的点）；
　　（5）要摸拟用户两三年内数据量的测试，而不仅仅是准备的一两条测试数据进行测试。
　　第二阶段，测试环境准备阶段
　　方案通过后，就可以开始着手准备测试环境：
　　（1）选择性能测试工具，并根据事先准备的数据模板开始收集测试数据；
　　（2）搭建被测系统的环境，并保证能正常运行，且没有性能测试范围内功能上的BUG出现；
　　（3）为被测系统录入初始数据，如VUSER需要用的账号，被测功能点需要用到的前置数据等。
　　在这一阶段的工作中，第（2）很重要，一定要保证程序没有功能上的问题，否则在进行性能测试后续工作时会有麻烦，比如脚本可能录制不成功或是不能回放等。
　　第三阶段，测试执行阶段
　　在此阶段有如下工作要做：
　　（1）录制脚本，对选定的需要进行性能测试的功能点进行脚本的录制；
　　（2）调试脚本，对录制好的脚本进行回放，对需要做关联的地方做关联，对需要做参数化的地方进行参数化，对需要做并发测试的点增加集合点等；
　　（3）设置场景并执行，根据制定的场景方案进行场景的设置，以及系统资源监控设置；
　　（4）收集测试结果，导出生成测试报告。
　　第四阶段，测试分析阶段
　　在此段只有一项工作需要做，但是却是性能测试工作中最重要的一点：
　　（1）分析测试数据，为系统调优做准备。
　　（2）提交测试报告，并给出系统性能最佳资源配置表单。

posted @ 2013-11-13 10:34 顺其自然EVO 阅读(184) | 评论 (0) | 编辑 收藏

JUnit单元测试实践：测试工具类和方法

　　工作中，为了提高Web开发的质量和效率，近期又为了保证自己的工具类等一系列可复用组件的质量，我煞费苦心地开始认真学习和撰写单元测试用例。
　　我现在已经厌倦了Debug程序，更讨厌Debug Web程序，太浪费时间了。
　　最近，线上的一个BM项目，出了个bug。浮点数相减，没有判断null，搞的我加班到9：30。
　　苦逼的码农啊。
　　下面，分享我的一个工具类和对应的单元测试用例。
　　有不对的地方，还望能告知我。大家共同进步。
/**
* 判断Collection(List和Set),Map等集合类型是否为空，是否含有空值。
* 判断String是否为空，参考ApacheCommonsLang-StringUtils。
*
* @author leiwen
*/
public class EmptyUtils {
/**
* 判断Collection(List和Set) 是否为空
*
* @param collection
*            List或Set类型的集合
* @return 如果collection是 null或size=0，返回true；否则，返回false。
*/
public static boolean isEmpty(Collection<?> collection) {
return collection == null || collection.size() == 0;
}
/**
* 判断map是否为空
*
* @param map
*            键值对数据类型
* @return 如果map是 null或size=0，返回true；否则，返回false。
*/
public static boolean isEmpty(Map<?, ?> map) {
return map == null || map.size() == 0;
}
/**
* 判断一个数组是否为空。
*
* @param array
*            对象数组
* @return 如果数组为null或者数组元素个数为0，返回true；否则，返回false。
*/
public static boolean isEmpty(Object[] array) {
return array == null || array.length == 0;
}
/**
* 判断Collection(List和Set) 不为空
*
* @param collection
*            List或Set类型的集合
* @return 如果collection不等于null且size>0，返回true；否则，返回false。
*/
public static boolean notEmpty(Collection<?> collection) {
return !isEmpty(collection);
}
/**
* 判断map不为空
*
* @param map
*            键值对数据类型
* @return 如果map不为 null且size>0，返回true；否则，返回false。
*/
public static boolean notEmpty(Map<?, ?> map) {
return !isEmpty(map);
}
/**
* 判断一个数组不为空。
*
* @param array
*            对象数组
* @return 如果数组为null或者数组元素个数为0，返回false；否则，返回true。
*/
public static boolean notEmpty(Object[] array) {
return !isEmpty(array);
}
}
package cn.fansunion.webcommon.platform;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import junit.framework.TestCase;
import org.junit.Test;
import cn.fansunion.common.util.EmptyUtils;
/**
*
*
* @author leiwen
*/
public class EmptyUtilsTest extends TestCase {
@Test
public static void testCollectionIsEmpty() {
List<Integer> list = Arrays.asList(1, 2, 3);
boolean listWithPositiveSize = EmptyUtils.isEmpty(list);
assertFalse(listWithPositiveSize);
List<Integer> emptyList = new ArrayList<Integer>();
boolean listWithZeroSize = EmptyUtils.isEmpty(emptyList);
assertTrue(listWithZeroSize);
List<Integer> nullList = null;
boolean nullEmpty = EmptyUtils.isEmpty(nullList);
assertTrue(nullEmpty);
Set<Integer> set = new HashSet<Integer>();
set.add(100);
boolean setWithPositiveSize = EmptyUtils.isEmpty(set);
assertFalse(setWithPositiveSize);
Set<Integer> nullSet = null;
assertTrue(EmptyUtils.isEmpty(nullSet));
Set<Integer> emptySet = new HashSet<Integer>();
assertTrue(EmptyUtils.isEmpty(emptySet));
}
@Test
public static void testMapIsEmpty() {
Map<String, Object> map = new HashMap<String, Object>();
map.put("mapTest", "mapTestValue");
assertFalse(EmptyUtils.isEmpty(map));
Map<String, Object> nullEmpty = null;
assertTrue(EmptyUtils.isEmpty(nullEmpty));
Map<String, Object> emptyMap = new HashMap<String, Object>();
assertTrue(EmptyUtils.isEmpty(emptyMap));
}
@Test
public static void testObjectArrayIsEmpty() {
Integer[] array = { 1, 2, 3 };
assertFalse(EmptyUtils.isEmpty(array));
Integer[] nullArray = null;
assertTrue(EmptyUtils.isEmpty(nullArray));
Integer[] emptyArray = {};
assertTrue(EmptyUtils.isEmpty(emptyArray));
}
@Test
public static void testCollectionNotEmpty() {
List<Integer> list = Arrays.asList(1, 2, 3);
boolean listWithPositiveSize = EmptyUtils.notEmpty(list);
assertTrue(listWithPositiveSize);
List<Integer> emptyList = new ArrayList<Integer>();
boolean listWithZeroSize = EmptyUtils.notEmpty(emptyList);
assertFalse(listWithZeroSize);
List<Integer> nullList = null;
boolean nullEmpty = EmptyUtils.notEmpty(nullList);
assertFalse(nullEmpty);
Set<Integer> set = new HashSet<Integer>();
set.add(100);
boolean setWithPositiveSize = EmptyUtils.notEmpty(set);
assertTrue(setWithPositiveSize);
Set<Integer> nullSet = null;
assertFalse(EmptyUtils.notEmpty(nullSet));
Set<Integer> emptySet = new HashSet<Integer>();
assertFalse(EmptyUtils.notEmpty(emptySet));
}
@Test
public static void testMapNotEmpty() {
Map<String, Object> map = new HashMap<String, Object>();
map.put("mapTest", "mapTestValue");
assertTrue(EmptyUtils.notEmpty(map));
Map<String, Object> nullEmpty = null;
assertFalse(EmptyUtils.notEmpty(nullEmpty));
Map<String, Object> emptyMap = new HashMap<String, Object>();
assertFalse(EmptyUtils.notEmpty(emptyMap));
}
@Test
public static void testObjectArrayNotEmpty() {
Integer[] array = { 1, 2, 3 };
assertTrue(EmptyUtils.notEmpty(array));
Integer[] nullArray = null;
assertFalse(EmptyUtils.notEmpty(nullArray));
Integer[] emptyArray = {};
assertFalse(EmptyUtils.notEmpty(emptyArray));
}
}

posted @ 2013-11-13 10:25 顺其自然EVO 阅读(299) | 评论 (0) | 编辑 收藏

Maven配置之pom文件配置包含和排除测试

　包含（Inclusions ）
　　默认情况下Surefire Plugin会自动的include下面这些格式的类：
　　“**/Test*.java” – includes所有以Test开头的java文件
　　“**/*Test.java” – includes所有以Test结尾的java文件
　　“**/*TestCase.java” – includes所有以TestCase结尾的java文件
　　当然我们也可以执行其它名字的类，或者说如果只想执行某一个或某几个用例，可以通过配置include来配置，如下:
　　排除（Exclusions ）
　　在mvn test的时候不想执行哪些用例，便可以通过exclude属性来配置，如下：
　　支持正则表达式（Regular expression support）
　　include/ecxlude属性支持类似ant风格的路径表达式，也支持正则表达式，语法如下：
　　注意语法 %regex[expr],这里expr是真正的表达式，另外请注意正则匹配.class文件而不是.java文件
相关文章：
Maven 编译打包时如何忽略测试用例

posted @ 2013-11-13 10:20 顺其自然EVO 阅读(645) | 评论 (0) | 编辑 收藏

仅列出标题
共394页: First 上一页 183 184 185 186 187 188 189 190 191 下一页 Last 
<2024年11月>
日一二三四五六
272829303112
3456789
10111213141516
17181920212223
24252627282930
1234567

导航

统计

常用链接

留言簿(55)

随笔分类

随笔档案

文章分类

文章档案

搜索

最新评论

阅读排行榜

评论排行榜