Java Assert.assertTrue方法代码示例

import org.pentaho.di.core.util.Assert; //导入方法依赖的package包/类
@Test public void testingLocalFileLockingByAcquiring2Locks() {

	CarbonTableIdentifier carbonTableIdentifier = new CarbonTableIdentifier("databaseName", "tableName", "tableId");
    LocalFileLock localLock1 =
        new LocalFileLock(carbonTableIdentifier,
            LockUsage.METADATA_LOCK);
    Assert.assertTrue(localLock1.lock());
    LocalFileLock localLock2 =
        new LocalFileLock(carbonTableIdentifier,
            LockUsage.METADATA_LOCK);
    Assert.assertTrue(!localLock2.lock());

    Assert.assertTrue(localLock1.unlock());
    Assert.assertTrue(localLock2.lock());

  }
 

import org.pentaho.di.core.util.Assert; //导入方法依赖的package包/类
/**
 * Write all the rows in the rowData array to an orc file
 *
 * @throws Exception
 */
private void testRecordWriter() throws Exception {
  IPentahoOutputFormat.IPentahoRecordWriter orcRecordWriter = orcOutputFormat.createRecordWriter();
  Assert.assertNotNull( orcRecordWriter, "orcRecordWriter should NOT be null!" );
  Assert.assertTrue( orcRecordWriter instanceof PentahoOrcRecordWriter,
    "orcRecordWriter should be instance of PentahoOrcRecordWriter" );

  for ( int i = 0; i < rowData.length; i++ ) {
    orcRecordWriter.write( new RowMetaAndData( rowMeta, rowData[ i ] ) );
  }
  try {
    orcRecordWriter.close();
  } catch ( Exception e ) {
    e.printStackTrace();
  }
}
 

import org.pentaho.di.core.util.Assert; //导入方法依赖的package包/类
private void testRecordWriter( List<AvroOutputField> avroOutputFields, RowMeta rowMeta, Object[] rowData,
                               IPentahoAvroOutputFormat.COMPRESSION compressionType, String filePath )
  throws Exception {

  PentahoAvroOutputFormat avroOutputFormat = new PentahoAvroOutputFormat();
  avroOutputFormat.setNameSpace( "nameSpace" );
  avroOutputFormat.setRecordName( "recordName" );
  avroOutputFormat.setFields( avroOutputFields );
  avroOutputFormat.setCompression( compressionType );
  avroOutputFormat.setOutputFile( filePath );

  IPentahoOutputFormat.IPentahoRecordWriter avroRecordWriter = avroOutputFormat.createRecordWriter();
  Assert.assertNotNull( avroRecordWriter, "avroRecordWriter should NOT be null!" );
  Assert.assertTrue( avroRecordWriter instanceof PentahoAvroRecordWriter,
    "avroRecordWriter should be instance of PentahoAvroRecordWriter" );

  avroRecordWriter.write( new RowMetaAndData( rowMeta, rowData ) );

  try {
    avroRecordWriter.close();
  } catch ( Exception e ) {
    e.printStackTrace();
  }
}
 

import org.pentaho.di.core.util.Assert; //导入方法依赖的package包/类
/**
 * Test whether a Millisecond-level timeout actually waits for N milliseconds, instead of N seconds
 */
@Test( timeout = 10000 )
public void testMillisecondWait() {
  int waitMilliseconds = 15;
  Job mockedJob = Mockito.mock( Job.class );
  Mockito.when( mockedJob.isStopped() ).thenReturn( false );

  JobEntryCheckDbConnections meta = new JobEntryCheckDbConnections();
  meta.setParentJob( mockedJob );
  meta.setLogLevel( LogLevel.BASIC );

  DatabaseMeta db = new DatabaseMeta( "InMemory H2", "H2", null, null, H2_DATABASE, "-1", null, null );
  meta.setConnections( new DatabaseMeta[]{ db } );
  meta.setWaittimes( new int[]{ JobEntryCheckDbConnections.UNIT_TIME_MILLI_SECOND } );
  meta.setWaitfors( new String[]{ String.valueOf( waitMilliseconds ) } );
  Result result = meta.execute( new Result(), 0 );
  Assert.assertTrue( result.getResult() );
}
 

import org.pentaho.di.core.util.Assert; //导入方法依赖的package包/类
@Test
public void test204Answer() throws Exception {
  startHttpServer( get204AnswerHandler() );
  HTTPData data = new HTTPData();
  int[] index = { 0, 1 };
  RowMeta meta = new RowMeta();
  meta.addValueMeta( new ValueMetaString( "fieldName" ) );
  meta.addValueMeta( new ValueMetaInteger( "codeFieldName" ) );
  Object[] expectedRow = new Object[] { "", 204L };
  HTTP http =
    new HTTPHandler( stepMockHelper.stepMeta, data, 0, stepMockHelper.transMeta, stepMockHelper.trans, false );
  RowMetaInterface inputRowMeta = mock( RowMetaInterface.class );
  http.setInputRowMeta( inputRowMeta );
  when( inputRowMeta.clone() ).thenReturn( inputRowMeta );
  when( stepMockHelper.processRowsStepMetaInterface.getUrl() ).thenReturn( HTTP_LOCALHOST_9998 );
  when( stepMockHelper.processRowsStepMetaInterface.getHeaderField() ).thenReturn( new String[] {} );
  when( stepMockHelper.processRowsStepMetaInterface.getArgumentField() ).thenReturn( new String[] {} );
  when( stepMockHelper.processRowsStepMetaInterface.getResultCodeFieldName() ).thenReturn( "ResultCodeFieldName" );
  when( stepMockHelper.processRowsStepMetaInterface.getFieldName() ).thenReturn( "ResultFieldName" );
  http.init( stepMockHelper.processRowsStepMetaInterface, data );
  Assert.assertTrue( http.processRow( stepMockHelper.processRowsStepMetaInterface, data ) );
  Object[] out = ( (HTTPHandler) http ).getOutputRow();
  Assert.assertTrue( meta.equals( out, expectedRow, index ) );
}
 

import org.pentaho.di.core.util.Assert; //导入方法依赖的package包/类
@Test
public void test204Answer() throws Exception {
  startHttpServer( get204AnswerHandler() );
  HTTPPOSTData data = new HTTPPOSTData();
  int[] index = { 0, 1 };
  RowMeta meta = new RowMeta();
  meta.addValueMeta( new ValueMetaString( "fieldName" ) );
  meta.addValueMeta( new ValueMetaInteger( "codeFieldName" ) );
  Object[] expectedRow = new Object[] { "", 204L };
  HTTPPOST HTTPPOST = new HTTPPOSTHandler(
    stepMockHelper.stepMeta, data, 0, stepMockHelper.transMeta, stepMockHelper.trans, false );
  RowMetaInterface inputRowMeta = mock( RowMetaInterface.class );
  HTTPPOST.setInputRowMeta( inputRowMeta );
  when( inputRowMeta.clone() ).thenReturn( inputRowMeta );
  when( stepMockHelper.processRowsStepMetaInterface.getUrl() ).thenReturn( HTTP_LOCALHOST_9998 );
  when( stepMockHelper.processRowsStepMetaInterface.getQueryField() ).thenReturn( new String[] {} );
  when( stepMockHelper.processRowsStepMetaInterface.getArgumentField() ).thenReturn( new String[] {} );
  when( stepMockHelper.processRowsStepMetaInterface.getResultCodeFieldName() ).thenReturn( "ResultCodeFieldName" );
  when( stepMockHelper.processRowsStepMetaInterface.getFieldName() ).thenReturn( "ResultFieldName" );
  HTTPPOST.init( stepMockHelper.processRowsStepMetaInterface, data );
  Assert.assertTrue( HTTPPOST.processRow( stepMockHelper.processRowsStepMetaInterface, data ) );
  Object[] out = ( (HTTPPOSTHandler) HTTPPOST ).getOutputRow();
  Assert.assertTrue( meta.equals( out, expectedRow, index ) );
}
 

import org.pentaho.di.core.util.Assert; //导入方法依赖的package包/类
public void testServerReturnsCorrectlyEncodedParams( String testString, String testCharset ) throws Exception {
  AtomicBoolean testStatus = new AtomicBoolean();
  startHttpServer( getEncodingCheckingHandler( testString, testCharset, testStatus ) );
  HTTPPOSTData data = new HTTPPOSTData();
  RowMeta meta = new RowMeta();
  meta.addValueMeta( new ValueMetaString( "fieldName" ) );
  HTTPPOSTHandler httpPost = new HTTPPOSTHandler(
    stepMockHelper.stepMeta, data, 0, stepMockHelper.transMeta, stepMockHelper.trans, false );
  RowMetaInterface inputRowMeta = mock( RowMetaInterface.class );
  httpPost.setInputRowMeta( inputRowMeta );
  httpPost.row = new Object[] { testString };
  when( inputRowMeta.clone() ).thenReturn( inputRowMeta );
  when( inputRowMeta.getString( httpPost.row, 0 ) ).thenReturn( testString );
  when( stepMockHelper.processRowsStepMetaInterface.getUrl() ).thenReturn( HTTP_LOCALHOST_9998 );
  when( stepMockHelper.processRowsStepMetaInterface.getQueryField() ).thenReturn( new String[] {} );
  when( stepMockHelper.processRowsStepMetaInterface.getArgumentField() )
    .thenReturn( new String[] { "testBodyField" } );
  when( stepMockHelper.processRowsStepMetaInterface.getArgumentParameter() )
    .thenReturn( new String[] { "testBodyParam" } );
  when( stepMockHelper.processRowsStepMetaInterface.getArgumentHeader() ).thenReturn( new boolean[] { false } );
  when( stepMockHelper.processRowsStepMetaInterface.getFieldName() ).thenReturn( "ResultFieldName" );
  when( stepMockHelper.processRowsStepMetaInterface.getEncoding() ).thenReturn( testCharset );
  httpPost.init( stepMockHelper.processRowsStepMetaInterface, data );
  Assert.assertTrue( httpPost.processRow( stepMockHelper.processRowsStepMetaInterface, data ) );
  Assert.assertTrue( testStatus.get(), "Test failed" );
}
 

import org.pentaho.di.core.util.Assert; //导入方法依赖的package包/类
@Test
public void createRecordWriterWhenSchemaAndPathIsNotNull() throws Exception {
  PentahoParquetOutputFormat pentahoParquetOutputFormat = new PentahoParquetOutputFormat();

  String tempFile = Files.createTempDirectory( "parquet" ).toUri().toString();
  pentahoParquetOutputFormat.setOutputFile( tempFile.toString() + "test", true );
  pentahoParquetOutputFormat.setSchema( ParquetUtils.createSchema() );

  IPentahoOutputFormat.IPentahoRecordWriter recordWriter = pentahoParquetOutputFormat.createRecordWriter();

  Assert.assertNotNull( recordWriter, "recordWriter should NOT be null!" );
  Assert.assertTrue( recordWriter instanceof IPentahoOutputFormat.IPentahoRecordWriter,
    "recordWriter should be instance of IPentahoInputFormat.IPentahoRecordReader" );
}
 

import org.pentaho.di.core.util.Assert; //导入方法依赖的package包/类
@Test
public void iterateOverParquetFileWithData() throws Exception {
  initSample();
  FileInputFormat.setInputPaths( job, getClass().getClassLoader().getResource( "sample.pqt" ).toExternalForm() );
  initializeRecordReader();
  PentahoParquetRecordReader recordReader = new PentahoParquetRecordReader( nativeRecordReader );

  Assert.assertTrue( recordReader.iterator().hasNext() );
  Assert.assertNotNull( recordReader.iterator().next() );

  recordReader.close();
}
 

import org.pentaho.di.core.util.Assert; //导入方法依赖的package包/类
/**
 * 
 * @throws Exception
 */
@org.junit.Test
public void testGetVersioningEnabled() throws Exception {
  FileVersioningConfiguration conf = revisionResource.doVersioningConfiguration( "foo.ktr" );
  Assert.assertTrue( conf.isVersioningEnabled() );
  Assert.assertFalse( conf.isVersionCommentEnabled() );
}
 

import org.pentaho.di.core.util.Assert; //导入方法依赖的package包/类
@Test
public void testResponseHeader() throws Exception {
  startHttpServer( get204AnswerHandler() );
  HTTPData data = new HTTPData();
  int[] index = { 0, 1, 3 };
  RowMeta meta = new RowMeta();
  meta.addValueMeta( new ValueMetaString( "fieldName" ) );
  meta.addValueMeta( new ValueMetaInteger( "codeFieldName" ) );
  meta.addValueMeta( new ValueMetaInteger( "responseTimeFieldName" ) );
  meta.addValueMeta( new ValueMetaString( "headerFieldName" ) );
  Object[] expectedRow =
    new Object[] { "", 402L, 0L, "{\"host\":\"localhost\"}" };
  HTTP http =
    new HTTPHandler( stepMockHelper.stepMeta, data, 0, stepMockHelper.transMeta, stepMockHelper.trans, true );
  RowMetaInterface inputRowMeta = mock( RowMetaInterface.class );
  http.setInputRowMeta( inputRowMeta );
  when( inputRowMeta.clone() ).thenReturn( inputRowMeta );
  when( stepMockHelper.processRowsStepMetaInterface.getUrl() ).thenReturn( HTTP_LOCALHOST_9998 );
  when( stepMockHelper.processRowsStepMetaInterface.getHeaderField() ).thenReturn( new String[] {} );
  when( stepMockHelper.processRowsStepMetaInterface.getArgumentField() ).thenReturn( new String[] {} );
  when( stepMockHelper.processRowsStepMetaInterface.getResultCodeFieldName() ).thenReturn( "ResultCodeFieldName" );
  when( stepMockHelper.processRowsStepMetaInterface.getFieldName() ).thenReturn( "ResultFieldName" );
  when( stepMockHelper.processRowsStepMetaInterface.getEncoding() ).thenReturn( "UTF8" );
  when( stepMockHelper.processRowsStepMetaInterface.getResponseTimeFieldName() ).thenReturn(
    "ResponseTimeFieldName" );
  when( stepMockHelper.processRowsStepMetaInterface.getResponseHeaderFieldName() ).thenReturn(
    "ResponseHeaderFieldName" );
  http.init( stepMockHelper.processRowsStepMetaInterface, data );
  Assert.assertTrue( http.processRow( stepMockHelper.processRowsStepMetaInterface, data ) );
  Object[] out = ( (HTTPHandler) http ).getOutputRow();
  Assert.assertTrue( meta.equals( out, expectedRow, index ) );

}
 

import org.pentaho.di.core.util.Assert; //导入方法依赖的package包/类
@Test
public void testDuplicateNamesInHeader() throws Exception {
  startHttpServer( getDuplicateHeadersHandler() );
  HTTPData data = new HTTPData();
  RowMeta meta = new RowMeta();
  meta.addValueMeta( new ValueMetaString( "headerFieldName" ) );
  HTTP http =
    new HTTPHandler( stepMockHelper.stepMeta, data, 0, stepMockHelper.transMeta, stepMockHelper.trans, false );
  RowMetaInterface inputRowMeta = mock( RowMetaInterface.class );
  http.setInputRowMeta( inputRowMeta );
  when( inputRowMeta.clone() ).thenReturn( inputRowMeta );
  when( stepMockHelper.processRowsStepMetaInterface.getUrl() ).thenReturn( HTTP_LOCALHOST_9998 );
  when( stepMockHelper.processRowsStepMetaInterface.getHeaderField() ).thenReturn( new String[] {} );
  when( stepMockHelper.processRowsStepMetaInterface.getArgumentField() ).thenReturn( new String[] {} );
  when( stepMockHelper.processRowsStepMetaInterface.getEncoding() ).thenReturn( "UTF8" );
  when( stepMockHelper.processRowsStepMetaInterface.getResponseHeaderFieldName() ).thenReturn(
    "ResponseHeaderFieldName" );
  http.init( stepMockHelper.processRowsStepMetaInterface, data );
  Assert.assertTrue( http.processRow( stepMockHelper.processRowsStepMetaInterface, data ) );
  Object[] out = ( (HTTPHandler) http ).getOutputRow();
  Assert.assertTrue( out.length == 1 );
  JSONParser parser = new JSONParser();
  JSONObject json = (JSONObject) parser.parse( (String) out[ 0 ] );
  Object userAgent = json.get( "User-agent" );
  Assert.assertTrue( "HTTPTool/1.0".equals( userAgent ) );
  Object cookies = json.get( "Set-cookie" );
  Assert.assertTrue( cookies instanceof JSONArray );
  for ( int i = 0; i < 3; i++ ) {
    String cookie = ( (String) ( (JSONArray) cookies ).get( i ) );
    Assert.assertTrue( cookie.startsWith( "cookie" + i ) );
  }
}
 

import org.pentaho.di.core.util.Assert; //导入方法依赖的package包/类
/**
 * 
 * @throws Exception
 */
@org.junit.Test
public void testDoGetVersions() throws Exception {
  Response response = revisionResource.doGetVersions( MOCK_FILE_PATH );
  Object entity = response.getEntity();

  // Yeah this gets weird: List, wrapped in a Response, wrapped in GenericEnttiy
  List<PurObjectRevision> revisionList = (List<PurObjectRevision>) ( (GenericEntity) entity ).getEntity();

  Assert.assertTrue( revisionList.size() == 1 );
  Assert.assertTrue( revisionList.get( 0 ).getLogin().equals( MOCK_VERSION_AUTHOR_1 ) );
}
 

import org.pentaho.di.core.util.Assert; //导入方法依赖的package包/类
@Test
public void testCreateMultivalueMap() {
  StepMeta stepMeta = new StepMeta();
  stepMeta.setName( "TestRest" );
  TransMeta transMeta = new TransMeta();
  transMeta.setName( "TestRest" );
  transMeta.addStep( stepMeta );
  Rest rest = new Rest( stepMeta, Mockito.mock( StepDataInterface.class ),
    1, transMeta, Mockito.mock( Trans.class ) );
  MultivaluedMapImpl map = rest.createMultivalueMap( "param1", "{a:{[val1]}}" );
  String val1 = map.getFirst( "param1" );
  Assert.assertTrue( val1.contains( "%7D" ) );
}
 

import org.pentaho.di.core.util.Assert; //导入方法依赖的package包/类
@Test
public void testDuplicateNamesInHeader() throws Exception {
  startHttpServer( getDuplicateHeadersHandler() );
  HTTPPOSTData data = new HTTPPOSTData();
  RowMeta meta = new RowMeta();
  meta.addValueMeta( new ValueMetaString( "headerFieldName" ) );
  HTTPPOST HTTPPOST = new HTTPPOSTHandler(
    stepMockHelper.stepMeta, data, 0, stepMockHelper.transMeta, stepMockHelper.trans, false );
  RowMetaInterface inputRowMeta = mock( RowMetaInterface.class );
  HTTPPOST.setInputRowMeta( inputRowMeta );
  when( inputRowMeta.clone() ).thenReturn( inputRowMeta );
  when( stepMockHelper.processRowsStepMetaInterface.getUrl() ).thenReturn( HTTP_LOCALHOST_9998 );
  when( stepMockHelper.processRowsStepMetaInterface.getQueryField() ).thenReturn( new String[] {} );
  when( stepMockHelper.processRowsStepMetaInterface.getArgumentField() ).thenReturn( new String[] {} );
  when( stepMockHelper.processRowsStepMetaInterface.getEncoding() ).thenReturn( "UTF-8" );
  when( stepMockHelper.processRowsStepMetaInterface.getResponseHeaderFieldName() ).thenReturn(
    "ResponseHeaderFieldName" );
  HTTPPOST.init( stepMockHelper.processRowsStepMetaInterface, data );
  Assert.assertTrue( HTTPPOST.processRow( stepMockHelper.processRowsStepMetaInterface, data ) );
  Object[] out = ( (HTTPPOSTHandler) HTTPPOST ).getOutputRow();
  Assert.assertTrue( out.length == 1 );
  JSONParser parser = new JSONParser();
  JSONObject json = (JSONObject) parser.parse( (String) out[ 0 ] );
  Object userAgent = json.get( "User-agent" );
  Assert.assertTrue( "HTTPTool/1.0".equals( userAgent ) );
  Object cookies = json.get( "Set-cookie" );
  Assert.assertTrue( cookies instanceof JSONArray );
  for ( int i = 0; i < 3; i++ ) {
    String cookie = ( (String) ( (JSONArray) cookies ).get( i ) );
    Assert.assertTrue( cookie.startsWith( "cookie" + i ) );
  }
}