Code
/
islandora
7
0
Fork 0
Code Issues Pull Requests 1 Projects Releases Wiki Activity
Browse Source

needs less if/then

pull/463/head
qadan 11 years ago
parent
058f1fc803
commit
ad503afbf0
2 changed files with 206 additions and 197 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 390
      tests/datastream_validators.inc
  2. 9
      tests/islandora_web_test_case.inc

390
tests/datastream_validators.inc
Unescape View File

@ -44,6 +44,79 @@ function islandora_hex2int($hex) {
} }
} }
/**
* A result from a datastream validator; $type defines TRUE/FALSE as pass/fail.
*/
class DatastreamValidatorResult {
/**
* The message for this result.
*
* @var string
*/
protected $message;
/**
* The caller for this result.
*
* @var array
*/
protected $caller;
/**
* The type of result this is - TRUE for pass, FALSE for fail.
*
* @var bool
*/
protected $type;
/**
* Constructs a DatastreamValidatorResult.
*
* @param bool $type
* Whether this result should indicate a pass (TRUE) or fail (FALSE).
* @param string $message
* The message that will be used by this result.
* @param array $caller
* The caller for this result.
*/
public function __construct($type, $message, array $caller) {
$this->message = $message;
$this->caller = $caller;
$this->type = $type;
}
/**
* Get the message for this result.
*
* @return string
* The message for this result.
*/
public function getMessage() {
return $this->message;
}
/**
* Get the caller for this result.
*
* @return string
* The caller for this result.
*/
public function getCaller() {
return $this->caller;
}
/**
* Get the type of result.
*
* @return bool
* The type of pass (TRUE for pass, FALSE for fail).
*/
public function getType() {
return $this->type;
}
}
/** /**
* Abstraction for datastream validators. * Abstraction for datastream validators.
* *
@ -66,13 +139,6 @@ function islandora_hex2int($hex) {
*/ */
abstract class DatastreamValidator { abstract class DatastreamValidator {
/**
* This class is skipped when looking for the source of an assertion.
*
* @see DrupalWebTestCase::skipClasses
*/
protected $skipClasses = array(__CLASS__ => TRUE);
/** /**
* The IslandoraFedoraObject containing the datastream to test. * The IslandoraFedoraObject containing the datastream to test.
* *
@ -95,24 +161,13 @@ abstract class DatastreamValidator {
public $datastreamContent; public $datastreamContent;
/** /**
* An associative array of messages returned from passed tests, and callers. * An array of DatastreamValidatorResults.
* *
* This should only be added to using $this->addPass(), so that the caller can * These should be generated using $this->addResult.
* be appropriately determined.
* *
* @var array * @var DatastreamValidatorResult[]
*/ */
public $passes = array(); public $results = array();
/**
* An associative array of messages returned from failed tests, and callers.
*
* This should only be added to using $this->addFail(), so that the caller can
* be appropriately determined.
*
* @var array
*/
public $fails = array();
/** /**
* An array of additional required parameters. * An array of additional required parameters.
@ -157,49 +212,26 @@ abstract class DatastreamValidator {
} }
/** /**
* Returns an array of pass messages. * Returns an array of DatastreamValidatorResults.
*
* @return string[]
* The pass messages.
*/
public function getPasses() {
return $this->passes;
}
/**
* Returns an array of fail messages.
*
* @return string[]
* The fail messages.
*/
public function getFails() {
return $this->fails;
}
/**
* Adds a pass to $this->pass.
* *
* Passes are an associative array of messages and callers. Callers should be * @return DatastreamValidatorResult[]
* obtained using $this->getAssertionCall(). * The results.
*
* @param string $message
* The message to use.
*/ */
public function addPass($message) { public function getResults() {
$this->passes[$message] = $this->getAssertionCall(); return $this->results;
} }
/** /**
* Adds a fail to $this->fail. * Adds a result to $this->results.
*
* Fails are an associative array of messages and callers. Callers should be
* obtained using $this->getAssertionCall().
* *
* @param bool $type
* The type of result (TRUE for pass, FALSE for fail).
* @param string $message * @param string $message
* The message to use. * The message to put in the result.
*/ */
public function addFail($message) { public function addResult($type, $message) {
$this->fails[$message] = $this->getAssertionCall(); $result = new DatastreamValidatorResult($type, $message, $this->getAssertionCall());
$this->results[] = $result;
} }
/** /**
@ -239,12 +271,11 @@ class ImageDatastreamValidator extends DatastreamValidator {
* Asserts the validity of an image using PHPGD. * Asserts the validity of an image using PHPGD.
*/ */
protected function assertImageGeneration() { protected function assertImageGeneration() {
if (imagecreatefromstring($this->datastreamContent) !== FALSE) { $assertion = imagecreatefromstring($this->datastreamContent) !== FALSE;
$this->addPass("Image datastream {$this->datastream} is valid."); $pass = "Image datastream {$this->datastream} is valid.";
} $fail = "Image datastream {$this->datastream} is either invalid or corrupt.";
else { $message = $assertion ? $pass : $fail;
$this->addFail("Image datastream {$this->datastream} is either invalid or corrupt."); $this->addResult($assertion, $message);
}
} }
} }
@ -264,17 +295,17 @@ class TIFFDatastreamValidator extends DatastreamValidator {
// byte-order" (i.e. little-endian) by starting with the characters "II" // byte-order" (i.e. little-endian) by starting with the characters "II"
// (repeated so that byte order does not yet need to be significant). // (repeated so that byte order does not yet need to be significant).
// The number that follows is '42' in little-endian hex, a number of // The number that follows is '42' in little-endian hex, a number of
// 'deep philosophical significance' to the TIFF format creators. // 'deep philosophical significance' to the TIFF format creators.'
$this->addPass("{$this->datastream} datastream asserts that it is a valid Intel-byte-orderded TIF/TIFF file."); $this->addResult(TRUE, "{$this->datastream} datastream asserts that it is a valid Intel-byte-orderded TIF/TIFF file.");
} }
elseif ($datastream_header_hex == "4d4d002a") { elseif ($datastream_header_hex == "4d4d002a") {
// In this case, the ingested TIFF is designated as using the "Motorola // In this case, the ingested TIFF is designated as using the "Motorola
// byte-order" (i.e. big-endian) by starting with the characters "MM" // byte-order" (i.e. big-endian) by starting with the characters "MM"
// instead. 42 follows once again, this time in big-endian hex. // instead. 42 follows once again, this time in big-endian hex.
$this->addPass("{$this->datastream} datastream asserts that it is a valid Motorola-byte-ordered TIF/TIFF file."); $this->addResult(TRUE, "{$this->datastream} datastream asserts that it is a valid Motorola-byte-ordered TIF/TIFF file.");
} }
else { else {
$this->addFail("{$this->datastream} datastream does not assert that it is a valid TIF/TIFF file."); $this->addResult(FALSE, "{$this->datastream} datastream does not assert that it is a valid TIF/TIFF file.");
} }
} }
@ -302,12 +333,11 @@ class JP2DatastreamValidator extends DatastreamValidator {
* 0x6A502020. This header is in all .jp2s, and we check for it here. * 0x6A502020. This header is in all .jp2s, and we check for it here.
*/ */
protected function assertJP2Header() { protected function assertJP2Header() {
if (substr(bin2hex($this->datastreamContent), 8, 8) == '6a502020') { $assertion = substr(bin2hex($this->datastreamContent), 8, 8) == '6a502020';
$this->addPass("Datastream {$this->datastream} contains the appropriate JP2 header."); $pass = "Datastream {$this->datastream} contains the appropriate JP2 header.";
} $fail = "Datastream {$this->datastream} does not contain the appropriate JP2 header.";
else { $message = $assertion ? $pass : $fail;
$this->addFail("Datastream {$this->datastream} does not contain the appropriate JP2 header."); $this->addResult($assertion, $message);
}
} }
/** /**
@ -317,12 +347,11 @@ class JP2DatastreamValidator extends DatastreamValidator {
* checking for it here to see if the .jp2 encoder finished okay. * checking for it here to see if the .jp2 encoder finished okay.
*/ */
protected function assertJP2Marker() { protected function assertJP2Marker() {
if (substr(bin2hex($this->datastreamContent), strlen(bin2hex($this->datastreamContent)) - 4, 4) == 'ffd9') { $assertion = substr(bin2hex($this->datastreamContent), strlen(bin2hex($this->datastreamContent)) - 4, 4) == 'ffd9';
$this->addPass("Datastream {$this->datastream} contains the appropriate JP2 ending marker."); $pass = "Datastream {$this->datastream} contains the appropriate JP2 ending marker.";
} $fail = "Datastream {$this->datastream} does not contain the appropriate JP2 ending marker. If this is the only JP2 validator that failed, it is likely that derivative generation was interrupted.";
else { $message = $assertion ? $pass : $fail;
$this->addFail("Datastream {$this->datastream} does not contain the appropriate JP2 ending marker. If this is the only JP2 validator that failed, it is likely that derivative generation was interrupted."); $this->addResult($assertion, $message);
}
} }
} }
@ -335,13 +364,12 @@ class PDFDatastreamValidator extends DatastreamValidator {
* Validates the PDF signature. * Validates the PDF signature.
*/ */
protected function assertPDFSignature() { protected function assertPDFSignature() {
if (substr($this->datastreamContent, 0, 5) == '%PDF-') { $assertion = substr($this->datastreamContent, 0, 5) == '%PDF-';
$pdf_version = substr($this->datastreamContent, 5, 3); $pdf_version = substr($this->datastreamContent, 5, 3);
$this->addPass("{$this->datastream} datastream asserts that it is a valid PDF file using PDF version {$pdf_version}"); $pass = "{$this->datastream} datastream asserts that it is a valid PDF file using PDF version {$pdf_version}";
} $fail = "{$this->datastream} datastream binary header appears to be corrupt and missing a valid PDF signature.";
else { $message = $assertion ? $pass : $fail;
$this->addFail("{$this->datastream} datastream binary header appears to be corrupt and missing a valid PDF signature."); $this->addResult($assertion, $message);
}
} }
/** /**
@ -349,12 +377,11 @@ class PDFDatastreamValidator extends DatastreamValidator {
*/ */
protected function assertPDFStreamCount() { protected function assertPDFStreamCount() {
$pdf_stream_count = substr_count(bin2hex($this->datastreamContent), '0a73747265616d0a'); $pdf_stream_count = substr_count(bin2hex($this->datastreamContent), '0a73747265616d0a');
if ($pdf_stream_count !== 0) { $assertion = $pdf_stream_count !== 0;
$this->addPass("{$this->datastream} datastream reports the existence of {$pdf_stream_count} PDF streams. Note that an extremely low number could still indicate corruption."); $pass = "{$this->datastream} datastream reports the existence of {$pdf_stream_count} PDF streams. Note that an extremely low number could still indicate corruption.";
} $fail = "{$this->datastream} datastream contains zero PDF streams, and is likely not a PDF file.";
else { $message = $assertion ? $pass : $fail;
$this->addFail("{$this->datastream} datastream contains zero PDF streams, and is likely not a PDF file."); $this->addResult($assertion, $message);
}
} }
/** /**
@ -364,12 +391,11 @@ class PDFDatastreamValidator extends DatastreamValidator {
* TRUE if it was present; FALSE otherwise. * TRUE if it was present; FALSE otherwise.
*/ */
protected function assertPDFClosingTag() { protected function assertPDFClosingTag() {
if (strpos(bin2hex($this->datastreamContent), '0a2525454f460a')) { $assertion = strpos(bin2hex($this->datastreamContent), '0a2525454f460a') == TRUE;
$this->addPass("{$this->datastream} datastream reports the existence of the closing 'EOF' tag required at the end of PDFs"); $pass = "{$this->datastream} datastream reports the existence of the closing 'EOF' tag required at the end of PDFs";
} $fail = "{$this->datastream} datastream does not contain the closing 'EOF' tag. If this is the only PDF validation that failed, it is likely that derivative generation was interrupted.";
else { $message = $assertion ? $pass : $fail;
$this->addFail("{$this->datastream} datastream does not contain the closing 'EOF' tag. If this is the only PDF validation that failed, it is likely that derivative generation was interrupted."); $this->addResult($assertion, $message);
}
} }
} }
@ -387,13 +413,13 @@ class TextDatastreamValidator extends DatastreamValidator {
*/ */
protected function assertTextStringCount() { protected function assertTextStringCount() {
if (!isset($this->params[1])) { if (!isset($this->params[1])) {
$this->addFail("TextDatastreamValidator cannot be instantiated without two keys in the 'params' variable."); $this->addResult(FALSE, "TextDatastreamValidator cannot be instantiated without two keys in the 'params' variable.");
return; return;
} }
$string_count = self::getTextStringCount(); $string_count = self::getTextStringCount();
$expected = $this->params[1]; $expected = $this->params[1];
$function = $string_count === $expected ? 'addPass' : 'addFail'; $assertion = $string_count === $expected;
$this->$function("{$this->datastream} datastream contains the word(s) '{$this->params[0]}' repeated {$string_count} time(s) (expected: {$expected})."); $this->addResult($assertion, "{$this->datastream} datastream contains the word(s) '{$this->params[0]}' repeated {$string_count} time(s) (expected: {$expected}).");
} }
/** /**
@ -442,36 +468,33 @@ class WAVDatastreamValidator extends DatastreamValidator {
*/ */
protected function assertWAVSignature() { protected function assertWAVSignature() {
$signatures = str_split(substr($this->datastreamContent, 0, 24), 8); $signatures = str_split(substr($this->datastreamContent, 0, 24), 8);
if ($signatures[0] = '52494646' && $signatures[2] = '57415645') { $assertion = $signatures[0] == '52494646' && $signatures[2] == '57415645';
$this->addPass("Header of the {$this->datastream} datastream contains a valid file signature."); $pass = "Header of the {$this->datastream} datastream contains a valid file signature.";
} $fail = "Header of the {$this->datastream} datastream contains corrupt file signature.";
else { $message = $assertion ? $pass : $fail;
$this->addFail("Header of the {$this->datastream} datastream contains corrupt file signature."); $this->addResult($assertion, $message);
}
} }
/** /**
* Asserts that the chunksize in the header is correct. * Asserts that the chunksize in the header is correct.
*/ */
protected function assertWAVChunkSize() { protected function assertWAVChunkSize() {
if (islandora_hex2int(substr($this->datastreamContent, 8, 8)) === 36 + self::getDataSubChunkSize()) { $assertion = islandora_hex2int(substr($this->datastreamContent, 8, 8)) === 36 + self::getDataSubChunkSize();
$this->addPass("{$this->datastream} datastream chunksize in WAV header is correct"); $pass = "{$this->datastream} datastream chunksize in WAV header is correct";
} $fail = "{$this->datastream} datastream chunksize in WAV header does not match actual chunksize.";
else { $message = $assertion ? $pass : $fail;
$this->addFail("{$this->datastream} datastream chunksize in WAV header does not match actual chunksize."); $this->addResult($assertion, $message);
}
} }
/** /**
* Asserts that the datastream contains a 'fmt' subchunk. * Asserts that the datastream contains a 'fmt' subchunk.
*/ */
protected function assertWAVFmtSubChunk() { protected function assertWAVFmtSubChunk() {
if (substr($this->datastreamContent, 24, 8) === '666d7420') { $assertion = substr($this->datastreamContent, 24, 8) === '666d7420';
$this->addPass("{$this->datastream} datastream contains a 'fmt' subchunk."); $pass = "{$this->datastream} datastream contains a 'fmt' subchunk.";
} $fail = "{$this->datastream} datastream is missing the required 'fmt' subchunk.";
else { $message = $assertion ? $pass : $fail;
$this->addFail("{$this->datastream} datastream is missing the required 'fmt' subchunk."); $this->addResult($assertion, $message);
}
} }
/** /**
@ -479,24 +502,22 @@ class WAVDatastreamValidator extends DatastreamValidator {
*/ */
protected function assertWAVByteRate() { protected function assertWAVByteRate() {
$wav_samplerate = islandora_hex2int(substr($this->datastreamContent, 48, 8)); $wav_samplerate = islandora_hex2int(substr($this->datastreamContent, 48, 8));
if (islandora_hex2int(substr($this->datastreamContent, 56, 8)) === $wav_samplerate * self::getNumChannels() * self::getBytesPerSample()) { $assertion = islandora_hex2int(substr($this->datastreamContent, 56, 8)) === $wav_samplerate * self::getNumChannels() * self::getBytesPerSample();
$this->addPass("{$this->datastream} datastream byterate in the WAV header is correct."); $pass = "{$this->datastream} datastream byterate in the WAV header is correct.";
} $fail = "{$this->datastream} datastream byterate in the WAV header does not match actual calculated byterate.";
else { $message = $assertion ? $pass : $fail;
$this->addFail("{$this->datastream} datastream byterate in the WAV header does not match actual calculated byterate."); $this->addResult($assertion, $message);
}
} }
/** /**
* Asserts that the block alignment is correct. * Asserts that the block alignment is correct.
*/ */
protected function assertWAVBlockAlignment() { protected function assertWAVBlockAlignment() {
if (islandora_hex2int(substr($this->datastreamContent, 64, 4)) === self::getNumChannels() * self::getBytesPerSample()) { $assertion = islandora_hex2int(substr($this->datastreamContent, 64, 4)) === self::getNumChannels() * self::getBytesPerSample();
$this->addPass("{$this->datastream} datastream block alignment is set correctly."); $pass = "{$this->datastream} datastream block alignment is set correctly.";
} $fail = "{$this->datastream} datastream block alignment is off.";
else { $message = $assertion ? $pass : $fail;
$this->addFail("{$this->datastream} datastream block alignment is off."); $this->addResult($assertion, $message);
}
} }
/** /**
@ -506,18 +527,17 @@ class WAVDatastreamValidator extends DatastreamValidator {
*/ */
protected function assertWAVDataSubChunk() { protected function assertWAVDataSubChunk() {
if (substr($this->datastreamContent, 72, 8) !== '64617461') { if (substr($this->datastreamContent, 72, 8) !== '64617461') {
$this->addFail("{$this->datastream} datastream is missing the 'data' subchunk."); $this->addResult(FALSE, "{$this->datastream} datastream is missing the 'data' subchunk.");
return; return;
} }
else { else {
$this->addPass("{$this->datastream} datastream contains 'data' subchunk."); $this->addResult(TRUE, "{$this->datastream} datastream contains 'data' subchunk.");
$wav_numsamples = strlen(substr($this->datastreamContent, 88)) / self::getNumChannels() / self::getBytesPerSample() / 2; $wav_numsamples = strlen(substr($this->datastreamContent, 88)) / self::getNumChannels() / self::getBytesPerSample() / 2;
if (self::getDataSubChunkSize() === $wav_numsamples * self::getNumChannels() * self::getBytesPerSample()) { $assertion = self::getDataSubChunkSize() === $wav_numsamples * self::getNumChannels() * self::getBytesPerSample();
$this->addPass("{$this->datastream} datastream 'data' chunk is the correct size."); $pass = "{$this->datastream} datastream 'data' chunk is the correct size.";
} $fail = "{$this->datastream} datastream 'data' chunk is sized incorrectly.";
else { $message = $assertion ? $pass : $fail;
$this->addFail("{$this->datastream} datastream 'data' chunk is sized incorrectly."); $this->addResult($assertion, $message);
}
} }
} }
@ -578,11 +598,11 @@ class MP3DatastreamValidator extends DatastreamValidator {
// out of the way first before we go doing a bunch of potentially pointless // out of the way first before we go doing a bunch of potentially pointless
// math. Check to see if the VBR flag (58696e67) isn't there. // math. Check to see if the VBR flag (58696e67) isn't there.
if (strpos($this->datastreamContent, '58696e67') == FALSE && substr($this->datastreamContent, 0, 4) == 'fffa') { if (strpos($this->datastreamContent, '58696e67') == FALSE && substr($this->datastreamContent, 0, 4) == 'fffa') {
$this->addPass("{$this->datastream} datastream is encoded as a valid MPEG-1 Layer 3 file with CRC protection"); $this->addResult(TRUE, "{$this->datastream} datastream is encoded as a valid MPEG-1 Layer 3 file with CRC protection");
return; return;
} }
if (strpos($this->datastreamContent, '58696e67') == FALSE && substr($this->datastreamContent, 0, 4) == 'fffb') { if (strpos($this->datastreamContent, '58696e67') == FALSE && substr($this->datastreamContent, 0, 4) == 'fffb') {
$this->addPass("{$this->datastream} datastream is encoded as a valid unprotected MPEG-1 Layer 3 file"); $this->addResult(TRUE, "{$this->datastream} datastream is encoded as a valid unprotected MPEG-1 Layer 3 file");
return; return;
} }
@ -610,12 +630,11 @@ class MP3DatastreamValidator extends DatastreamValidator {
if (($mp3_flag_value + 4) % 4 > 1) { if (($mp3_flag_value + 4) % 4 > 1) {
$mp3_field_bytes = hexdec(substr($mp3_vbrheader, $mp3_field_offset[0] + 16, 8)); $mp3_field_bytes = hexdec(substr($mp3_vbrheader, $mp3_field_offset[0] + 16, 8));
$mp3_size = strlen($this->datastreamContent) / 2; $mp3_size = strlen($this->datastreamContent) / 2;
if ($mp3_size == $mp3_field_bytes) { $assertion = $mp3_size == $mp3_field_bytes;
$this->addPass("{$this->datastream} datastream reported filesize of {$mp3_size} bytes matches size field value of {$mp3_field_bytes}"); $pass = "{$this->datastream} datastream reported filesize of {$mp3_size} bytes matches size field value of {$mp3_field_bytes}";
} $fail = "{$this->datastream} datastream reported filesize of {$mp3_size} bytes does not match size field value of {$mp3_field_bytes}";
else { $message = $assertion ? $pass : $fail;
$this->addFail("{$this->datastream} datastream reported filesize of {$mp3_size} bytes does not match size field value of {$mp3_field_bytes}"); $this->addResult($assertion, $message);
}
$mp3_field_offset[1] += 8; $mp3_field_offset[1] += 8;
$mp3_field_offset[2] += 8; $mp3_field_offset[2] += 8;
} }
@ -628,18 +647,17 @@ class MP3DatastreamValidator extends DatastreamValidator {
// The fourth flag leads us to VBR quality data, which we can validate. // The fourth flag leads us to VBR quality data, which we can validate.
if ($mp3_flag_value > 7) { if ($mp3_flag_value > 7) {
$mp3_field_quality = hexdec(substr($mp3_vbrheader, $mp3_field_offset[2] + 16, 8)); $mp3_field_quality = hexdec(substr($mp3_vbrheader, $mp3_field_offset[2] + 16, 8));
if ($mp3_field_quality <= 100 && $mp3_field_quality >= 0) { $assertion = $mp3_field_quality <= 100 && $mp3_field_quality >= 0;
$this->addPass("{$this->datastream} datastream reports valid VBR quality of {$mp3_field_quality} (expected: between 0-100)"); $pass = "{$this->datastream} datastream reports valid VBR quality of {$mp3_field_quality} (expected: between 0-100)";
} $fail = "{$this->datastream} datastream reports invalid VBR quality of {$mp3_field_quality} (expected: between 0-100)";
else { $message = $assertion ? $pass : $fail;
$this->addFail("{$this->datastream} datastream reports invalid VBR quality of {$mp3_field_quality} (expected: between 0-100)"); $this->addResult($assertion, $message);
}
} }
} }
// If none of that works out, fail. // If none of that works out, fail.
else { else {
$this->addFail("{$this->datastream} datastream is corrupt and does not identify as a valid MP3."); $this->addResult(FALSE, "{$this->datastream} datastream is corrupt and does not identify as a valid MP3.");
} }
} }
@ -660,13 +678,12 @@ class MP4DatastreamValidator extends DatastreamValidator {
* Asserts that the datastream is ISO-formatted video. * Asserts that the datastream is ISO-formatted video.
*/ */
protected function assertISOVideo() { protected function assertISOVideo() {
if (strpos($this->datastreamContent, 'ftyp')) {
$mp4_ftyp = substr(strpos($this->datastreamContent, 'ftyp'), 4, 4); $mp4_ftyp = substr(strpos($this->datastreamContent, 'ftyp'), 4, 4);
$this->addPass("{$this->datastream} datastream asserts that it is a valid ISO-formatted video file using ftyp {$mp4_ftyp}"); $assertion = strpos($this->datastreamContent, 'ftyp') !== 0;
} $pass = "{$this->datastream} datastream asserts that it is a valid ISO-formatted video file using ftyp {$mp4_ftyp}";
else { $fail = "{$this->datastream} datastream is not a valid ISO-formatted video";
$this->addFail("{$this->datastream} datastream is not a valid ISO-formatted video"); $message = $assertion ? $pass : $fail;
} $this->addResult($assertion, $message);
} }
} }
@ -686,36 +703,33 @@ class OGGDatastreamValidator extends DatastreamValidator {
*/ */
protected function assertOGGPages() { protected function assertOGGPages() {
$ogg_pages = substr_count($this->datastreamContent, 'OggS'); $ogg_pages = substr_count($this->datastreamContent, 'OggS');
if ($ogg_pages !== 0) { $assertion = $ogg_pages !== 0;
$this->addPass("{$this->datastream} datastream asserts that it contains {$ogg_pages} Ogg pages (even a very small file should contain several)."); $pass = "{$this->datastream} datastream asserts that it contains {$ogg_pages} Ogg pages (even a very small file should contain several).";
} $fail = "{$this->datastream} datastream contains no Ogg pages.";
else { $message = $assertion ? $pass : $fail;
$this->addFail("{$this->datastream} datastream contains no Ogg pages."); $this->addResult($assertion, $message);
}
} }
/** /**
* Asserts that the datastream contains Theora-encoded video. * Asserts that the datastream contains Theora-encoded video.
*/ */
protected function assertTheoraVideo() { protected function assertTheoraVideo() {
if (substr_count($this->datastreamContent, 'theora') !== 0) { $assertion = substr_count($this->datastreamContent, 'theora') !== 0;
$this->addPass("{$this->datastream} datastream asserts that it contains Theora-encoded video data."); $pass = "{$this->datastream} datastream asserts that it contains Theora-encoded video data.";
} $fail = "{$this->datastream} datastream contains no marker indicating the presence of Theora-encoded video data.";
else { $message = $assertion ? $pass : $fail;
$this->addFail("{$this->datastream} datastream contains no marker indicating the presence of Theora-encoded video data."); $this->addResult($assertion, $message);
}
} }
/** /**
* Asserts that the datastream contains Vorbis-encoded audio. * Asserts that the datastream contains Vorbis-encoded audio.
*/ */
protected function assertVorbisAudio() { protected function assertVorbisAudio() {
if (substr_count($this->datastreamContent, 'vorbis')) { $assertion = substr_count($this->datastreamContent, 'vorbis') !== 0;
$this->addPass("{$this->datastream} datastream asserts that it contains Vorbis-encoded audio data"); $pass = "{$this->datastream} datastream asserts that it contains Vorbis-encoded audio data";
} $fail = "{$this->datastream} datastream contains no marker indicating the presence of Vorbis-encoded audio data.";
else { $message = $assertion ? $pass : $fail;
$this->addFail("{$this->datastream} datastream contains no marker indicating the presence of Vorbis-encoded audio data."); $this->addResult($assertion, $message);
}
} }
} }
@ -735,23 +749,21 @@ class MKVDatastreamValidator extends DatastreamValidator {
* Asserts that the datastream is an EBML-format file. * Asserts that the datastream is an EBML-format file.
*/ */
protected function assertEBMLFormat() { protected function assertEBMLFormat() {
if (substr(bin2hex($this->datastreamContent), 0, 8) == '1a45dfa3') { $assertion = substr(bin2hex($this->datastreamContent), 0, 8) == '1a45dfa3';
$this->addPass("{$this->datastream} datastream asserts that it is an EBML-formatted file"); $pass = "{$this->datastream} datastream asserts that it is an EBML-formatted file";
} $fail = "{$this->datastream} datastream is not an EBML-formatted file.";
else { $message = $assertion ? $pass : $fail;
$this->addFail("{$this->datastream} datastream is not an EBML-formatted file."); $this->addResult($assertion, $message);
}
} }
/** /**
* Asserts that the datastream contains a matroska marker. * Asserts that the datastream contains a matroska marker.
*/ */
protected function assertMatroskaMarker() { protected function assertMatroskaMarker() {
if (substr_count($this->datastreamContent, 'matroska') == 1) { $assertion = substr_count($this->datastreamContent, 'matroska') == 1;
$this->addPass("{$this->datastream} datastream asserts that its EBML DocType is Matroska"); $pass = "{$this->datastream} datastream asserts that its EBML DocType is Matroska";
} $fail = "{$this->datastream} datastream does not contain a Matroska EBML DocType marker.";
else { $message = $assertion ? $pass : $fail;
$this->addFail("{$this->datastream} datastream does not contain a Matroska EBML DocType marker."); $this->addResult($assertion, $message);
}
} }
} }

9
tests/islandora_web_test_case.inc
Unescape View File

@ -266,15 +266,12 @@ class IslandoraWebTestCase extends DrupalWebTestCase {
} }
} }
// Instantiate the appropriate class, grab the passes and fails. // Instantiate the appropriate class, and grab the results.
$class_name = "{$prefix}DatastreamValidator"; $class_name = "{$prefix}DatastreamValidator";
if (class_exists($class_name)) { if (class_exists($class_name)) {
$validator = new $class_name($object, $dsid, $params); $validator = new $class_name($object, $dsid, $params);
foreach ($validator->getPasses() as $message => $caller) { foreach ($validator->getResults() as $result) {
$this->assert(TRUE, $message, 'Islandora', $caller); $this->assert($result->getType(), $result->getMessage(), 'Islandora', $result->getCaller());
}
foreach ($validator->getFails() as $message => $caller) {
$this->assert(FALSE, $message, 'Islandora', $caller);
} }
} }
else { else {

Write Preview
Loading…
Cancel
Save