/Applications/MAMP/htdocs/quail/trunk/quail/common/accessibility_tests.php

<?php


class aAdjacentWithSameResourceShouldBeCombined extends quailTest {
        
        var $default_severity = QUAIL_TEST_SEVERE;
        
        function check() {
                foreach($this->getAllElements('a') as $a) {
                        if($this->propertyIsEqual($a->nextSibling, 'wholeText', '', true))
                                $next = $a->nextSibling->nextSibling;
                        else
                                $next = $a->nextSibling;
                        if($this->propertyIsEqual($next, 'tagName', 'a')) {
                                if($a->getAttribute('href') == $next->getAttribute('href'))
                                        $this->addReport($a);
                        }
                }
        }
}

class aImgAltNotRepetative extends quailTest {

        var $default_severity = QUAIL_TEST_SEVERE;


        function check() {
                foreach($this->getAllElements('a') as $a) {
                        foreach($a->childNodes as $child) {
                                if($this->propertyIsEqual($child, 'tagName', 'img')) {
                                        if(trim($a->nodeValue) == trim($child->getAttribute('alt')))
                                                $this->addReport($child);
                                }
                        }
                }
        }
}

class aLinkTextDoesNotBeginWithRedundantWord extends quailTest {

        var $default_severity = QUAIL_TEST_SEVERE;
        
        var $strings = array('en' => array('link to', 'go to'),
                                                 'es' => array('enlaces a', 'ir a')
                                                );
        
        function check() {
                foreach($this->getAllElements('a') as $a) {
                        if(!$a->nodeValue) {
                                if(property_exists($a, 'firstChild') && $this->propertyIsEqual($a->firstChild, 'tagName', 'img')) {
                                        $text = $a->firstChild->getAttribute('alt');
                                }
                        }
                        else 
                                $text = $a->nodeValue;
                        foreach($this->translation() as $word) {
                                if(strpos(trim($text), $word) === 0)
                                        $this->addReport($a);
                        }
                }
        }
}

class aLinksAreSeperatedByPrintableCharacters extends quailTest {

        var $default_severity = QUAIL_TEST_SEVERE;

        function check() {
                foreach($this->getAllElements('a') as $a) {
                        if(property_exists($a, 'nextSibling') 
                                && is_object($a->nextSibling)
                            && property_exists($a->nextSibling, 'nextSibling') 
                                && $this->propertyIsEqual($a->nextSibling->nextSibling, 'tagName', 'a') 
                                && ($this->propertyIsEqual($a->nextSibling, 'wholeText', '', true)
                                        || !property_exists($a->nextSibling, 'wholeText')
                                        || $this->propertyIsEqual($a->nextSibling, 'nodeValue', '', true)
                                        )
                                ) {                                     
                                        $this->addReport($a);
                        }
                }
        }
}

class aLinksDontOpenNewWindow extends quailTest {

        var $default_severity = QUAIL_TEST_SEVERE;
        
        var $allowed_targets = array('_self', '_parent', '_top');
        
        function check() {
                foreach($this->getAllElements('a') as $a) {
                        if($a->hasAttribute('target') 
                                && !in_array($a->getAttribute('target'), $this->allowed_targets)) {
                                        $this->addReport($a);
                        }
                }
        }

}

class aLinksMakeSenseOutOfContext extends quailTest {

        var $default_severity = QUAIL_TEST_SUGGESTION;
        
        function check() {
                foreach($this->getAllElements('a') as $a) {
                        if(strlen($a->nodeValue) > 1)
                                $this->addReport($a);
                }
        }

}

class aLinksToMultiMediaRequireTranscript extends quailTest {

        var $default_severity = QUAIL_TEST_SUGGESTION;
        
        var $extensions = array('wmv', 'mpg', 'mov', 'ram', 'aif');
        
        function check() {
                foreach($this->getAllElements('a') as $a) {
                        if($a->hasAttribute('href')) {
                                $filename = explode('.', $a->getAttribute('href'));
                                $extension = array_pop($filename);
                                if(in_array($extension, $this->extensions))
                                        $this->addReport($a);
                        }
                }
        }

}

class aLinksToSoundFilesNeedTranscripts extends quailTest {

        var $default_severity = QUAIL_TEST_SUGGESTION;
        
        var $extensions = array('wav', 'snd', 'mp3', 'iff', 'svx', 'sam', 'smp', 'vce', 'vox', 'pcm', 'aif');
        
        function check() {
                foreach($this->getAllElements('a') as $a) {
                        if($a->hasAttribute('href')) {
                                $filename = explode('.', $a->getAttribute('href'));
                                $extension = array_pop($filename);
                                if(in_array($extension, $this->extensions))
                                        $this->addReport($a);
                        }
                }
        }
}

class aMultimediaTextAlternative extends quailTest {

        var $default_severity = QUAIL_TEST_SUGGESTION;
        
        var $extensions = array('wmv', 'wav',  'mpg', 'mov', 'ram', 'aif');
        
        function check() {
                foreach($this->getAllElements('a') as $a) {
                        if($a->hasAttribute('href')) {
                                $extension = substr($a->getAttribute('href'), 
                                                         (strrpos($a->getAttribute('href'), '.') + 1), 4);
                                if(in_array($extension, $this->extensions))
                                        $this->addReport($a);
                        }
                }
        }
}

class aMustContainText extends quailTest {

        var $default_severity = QUAIL_TEST_SEVERE;

        function check() {
                foreach($this->getAllElements('a') as $a) {
                        if(!$this->elementContainsReadableText($a) && ($a->hasAttribute('href'))) {
                                $this->addReport($a);
                        }
                }
        }
        
        function isNotAnchor($a) {
                return (!($a->hasAttribute('name') && !$a->hasAttribute('href')));
        }
}

class aMustHaveTitle extends quailTest {

        var $default_severity = QUAIL_TEST_SEVERE;

        function check() {
                foreach($this->getAllElements('a') as $a) {
                        if(!$a->hasAttribute('title'))
                                $this->addReport($a);
                }
        
        }
}

class aMustNotHaveJavascriptHref extends quailTest {

        var $default_severity = QUAIL_TEST_SEVERE;

        function check() {
                foreach($this->getAllElements('a') as $a) {
                        if(substr(trim($a->getAttribute('href')), 0, 11) == 'javascript:')
                                $this->addReport($a);
                }
        }       
}

class aSuspiciousLinkText extends quailTest {

        var $default_severity = QUAIL_TEST_SEVERE;

        var $strings = array('en' => array('click here', 'click', 'more', 'here'),
                'es' => array('clic aqu&iacute;', 'clic', 'haga clic', 'm&aacute;s', 'aqu&iacute;'));

        function check() {
                foreach($this->getAllElements('a') as $a) {
                        if(in_array(strtolower(trim($a->nodeValue)), $this->translation()))
                                $this->addReport($a);
                }
        
        }
}

class aTitleDescribesDestination extends quailTest {

        var $default_severity = QUAIL_TEST_SUGGESTION;

        function check() {
                foreach($this->getAllElements('a') as $a) {
                        if($a->hasAttribute('title'))
                                $this->addReport($a);
                }
        
        }
}

class addressForAuthor extends quailTest {

        var $default_severity = QUAIL_TEST_SEVERE;
        
        var $cms = false;

        function check() {
                foreach($this->getAllElements('address') as $address) {
                        foreach($address->childNodes as $child) {
                                if($this->propertyIsEqual($child, 'tagName', 'a'))
                                                return true;
                        }
                }
                $this->addReport(null, null, false);
        }

}

class addressForAuthorMustBeValid extends quailTest {

        var $default_severity = QUAIL_TEST_MODERATE;
        
        function check() {
                foreach($this->getAllElements('address') as $address) {
                        if ($this->validateEmailAddress($address->nodeValue, array('check_domain' => $this->checkDomain)))
                                return true;
                        foreach($address->childNodes as $child) {
                                if($this->propertyIsEqual($child, 'tagName', 'a') 
                                   && substr(strtolower($child->getAttribute('href')), 0, 7) == 'mailto:') {
                                        if($this->validateEmailAddress(trim(str_replace('mailto:', '', $child->getAttribute('href'))), 
                                                array('check_domain' => $this->checkDomain)))
                                                        return true;
                                
                                }
                        }
                }
                $this->addReport(null, null, false);
        }


        function validateEmailAddress($email) {
          // First, we check that there's one @ symbol, 
          // and that the lengths are right.
          if (!ereg("^[^@]{1,64}@[^@]{1,255}$", $email)) {
            // Email invalid because wrong number of characters 
            // in one section or wrong number of @ symbols.
            return false;
          }
          // Split it into sections to make life easier
          $email_array = explode("@", $email);
          $local_array = explode(".", $email_array[0]);
          for ($i = 0; $i < sizeof($local_array); $i++) {
            if
        (!ereg("^(([A-Za-z0-9!#$%&'*+/=?^_`{|}~-][A-Za-z0-9!#$%&'*+/=?^_`{|}~\.-]{0,63})|(\"[^(\\|\")]{0,62}\"))$",
        $local_array[$i])) {
              return false;
            }
          }
          // Check if domain is IP. If not, 
          // it should be valid domain name
          if (!ereg("^\[?[0-9\.]+\]?$", $email_array[1])) {
            $domain_array = explode(".", $email_array[1]);
            if (sizeof($domain_array) < 2) {
                return false; // Not enough parts to domain
            }
            for ($i = 0; $i < sizeof($domain_array); $i++) {
              if
        (!ereg("^(([A-Za-z0-9][A-Za-z0-9-]{0,61}[A-Za-z0-9])|([A-Za-z0-9]+))$",
        $domain_array[$i])) {
                return false;
              }
            }
          }
          return true;
        }

}

class appletContainsTextEquivalent extends quailTest {

        var $default_severity = QUAIL_TEST_SEVERE;
        
        function check() {
                foreach($this->getAllElements('applet') as $applet) {
                        if(trim($applet->nodeValue) == '' || !$applet->nodeValue)
                                $this->addReport($applet);

                }
        }

}

class appletContainsTextEquivalentInAlt extends quailTest {

        var $default_severity = QUAIL_TEST_MODERATE;

        
        function check() {
                foreach($this->getAllElements('applet') as $applet) {
                        if(!$applet->hasAttribute('alt') || $applet->getAttribute('alt') == '')
                                $this->addReport($applet);

                }
        }

}

class appletProvidesMechanismToReturnToParent extends quailTagTest {

        var $default_severity = QUAIL_TEST_SUGGESTION;


        var $tag = 'applet';
}

class appletTextEquivalentsGetUpdated extends quailTagTest {

        var $default_severity = QUAIL_TEST_SUGGESTION;

        var $tag = 'applet';

}

class appletUIMustBeAccessible extends quailTagTest {

        var $default_severity = QUAIL_TEST_SUGGESTION;

        var $tag = 'applet';
}

class appletsDoNotFlicker extends quailTagTest {

        var $default_severity = QUAIL_TEST_SUGGESTION;

        var $tag = 'applet';

}

class appletsDoneUseColorAlone extends quailTagTest {

        var $default_severity = QUAIL_TEST_SUGGESTION;

        var $tag = 'applet';
}

class areaAltIdentifiesDestination extends quailTagTest {

        var $default_severity = QUAIL_TEST_SUGGESTION;

        var $tag = 'area';

}

class areaAltRefersToText extends quailTagTest {

        var $default_severity = QUAIL_TEST_SUGGESTION;

        var $tag = 'area';
}

class areaDontOpenNewWindow extends quailTest {

        var $default_severity = QUAIL_TEST_SEVERE;
        
        var $allowed_targets = array('_self', '_parent', '_top');
        
        function check() {
                foreach($this->getAllElements('area') as $area) {
                        if($area->hasAttribute('target') 
                                && !in_array($area->getAttribute('target'), $this->allowed_targets)) {
                                        $this->addReport($area);
                        }
                }
        }

}

class areaHasAltValue extends quailTest {

        var $default_severity = QUAIL_TEST_SEVERE;

        function check() {
                foreach($this->getAllElements('area') as $area) {
                        if(!$area->hasAttribute('alt'))
                                $this->addReport($area);
                }
        }

}

class areaLinksToSoundFile extends quailTest {

        var $default_severity = QUAIL_TEST_SUGGESTION;
        
        var $extensions = array('wav', 'snd', 'mp3', 'iff', 'svx', 'sam', 'smp', 'vce', 'vox', 'pcm', 'aif');
        
        function check() {
                foreach($this->getAllElements('area') as $area) {
                        if($area->hasAttribute('href')) {
                                $filename = explode('.', $area->getAttribute('href'));
                                $extension = array_pop($filename);
                                if(in_array($extension, $this->extensions))
                                        $this->addReport($area);
                        }
                }
        }

}

class basefontIsNotUsed extends quailTagTest {

        var $default_severity = QUAIL_TEST_SEVERE;

        var $tag = 'basefont';
}

class blinkIsNotUsed extends quailTagTest {

        var $default_severity = QUAIL_TEST_SEVERE;

        var $tag = 'blink';

}

class blockquoteNotUsedForIndentation extends quailTest {

        var $default_severity = QUAIL_TEST_MODERATE;

        function check() {
                foreach($this->getAllElements('blockquote') as $blockquote) {
                        if(!$blockquote->hasAttribute('cite'))
                                $this->addReport($blockquote);
                }
        }
}

class blockquoteUseForQuotations extends quailTest {

        var $default_severity = QUAIL_TEST_MODERATE;

        function check() {
                foreach($this->getAllElements('p') as $paragraph) {
                        if(in_array(substr(trim($paragraph->nodeValue), 0, 1), array('"', "'")) &&
                           in_array(substr(trim($paragraph->nodeValue), -1, 1), array('"', "'"))) {
                                $this->addReport($paragraph);
                        }
                }
        }

}

class bodyActiveLinkColorContrast extends bodyColorContrast {

        var $default_severity = QUAIL_TEST_SEVERE;

        var $cms = false;

        var $foreground = 'alink';
}




class bodyLinkColorContrast extends bodyColorContrast {

        var $default_severity = QUAIL_TEST_SEVERE;

        var $cms = false;

        var $foreground = 'link';
}

class bodyMustNotHaveBackground extends quailTest {

        var $default_severity = QUAIL_TEST_SEVERE;

        var $cms = false;
        
        function check() {
                $body = $this->getAllElements('body');
                if(!$body)
                        return false;
                $body = $body[0];
                if($body->hasAttribute('background'))
                        $this->addReport(null, null, false);
        }
}

class bodyVisitedLinkColorContrast extends bodyColorContrast {

        var $default_severity = QUAIL_TEST_SEVERE;

        var $cms = false;
        
        var $foreground = 'vlink';
}

class boldIsNotUsed extends quailTagTest {

        var $default_severity = QUAIL_TEST_SEVERE;

        var $tag = 'bold';
}

class checkboxHasLabel extends inputHasLabel {

        var $default_severity = QUAIL_TEST_SEVERE;

        var $tag = 'input';
        
        var $type = 'checkbox';
        
        var $no_type = false;
}

class checkboxLabelIsNearby extends quailTest {

        var $default_severity = QUAIL_TEST_MODERATE;

        function check() {
                foreach($this->getAllElements('input') as $input) {
                        if($input->getAttribute('type') == 'checkbox')
                                $this->addReport($input);
                        
                }
        }
}

class cssDocumentMakesSenseStyleTurnedOff extends quailTest {

        var $default_severity = QUAIL_TEST_SUGGESTION;

        function check() {
                foreach($this->getAllElements('link') as $link) {
                        if($link->parentNode->tagName == 'head') {
                                if($link->getAttribute('rel') == 'stylesheet')
                                        $this->addReport($link);
                        }
                }
        }
}

class cssTextHasContrast extends quailColorTest {

        var $default_severity = QUAIL_TEST_SEVERE;
        
        var $default_background = '#ffffff';

        var $default_color = '#000000';
        
        function check() {
                if(isset($this->options['css_background'])) {
                        $this->default_background = $this->options['css_background'];
                }
                if(isset($this->options['css_foreground'])) {
                        $this->default_color = $this->options['css_foreground'];
                }
                $xpath = new DOMXPath($this->dom);
                $entries = $xpath->query('//*');
                foreach($entries as $element) {
                        $style = $this->css->getStyle($element);
                        if((isset($style['background']) || isset($style['background-color'])) && isset($style['color']) && $element->nodeValue) {
                                $background = (isset($style['background-color']))
                                                           ? $style['background-color']
                                                           : $style['background'];
                                if(!$background || $this->options['css_only_use_default']) {
                                        $background = $this->default_background;
                                }
                                $luminosity = $this->getLuminosity(
                                                                $style['color'],
                                                                $background
                                                                );
                                if($luminosity < 5) {
                                        $this->addReport($element, 'background: '. $background .' fore: '. $style['color'] . ' lum: '. $luminosity);
                                }
                        }
                }       
                
        }

}

class doctypeProvided extends quailTest {

        var $default_severity = QUAIL_TEST_SEVERE;

        function check() {
                if(!$this->dom->doctype->publicId)
                        $this->addReport(null, null, false);            
        }

}

class documentAbbrIsUsed extends quailTest {

        var $default_severity = QUAIL_TEST_MODERATE;
        
        var $acronym_tag = 'abbr';
        
        function check() {
                foreach($this->getAllElements($this->acronym_tag) as $acronym) {
                        $predefined[strtoupper(trim($acronym->nodeValue))] = $acronym->getAttribute('title');
                }
                $already_reported = array();
                foreach($this->getAllElements(null, 'text') as $text) {

                        $words = explode(' ', $text->nodeValue);
                        if(count($words) > 1 && strtoupper($text->nodeValue) != $text->nodeValue) {
                                foreach($words as $word) {
                                        $word = preg_replace("/[^a-zA-Zs]/", "", $word);
                                        if(strtoupper($word) == $word && strlen($word) > 1 && !isset($predefined[strtoupper($word)]))

                                                if(!isset($already_reported[strtoupper($word)])) {
                                                        $this->addReport($text, 'Word "'. $word .'" requires an <code>'. $this->acronym_tag .'</code> tag.');
                                                }
                                                $already_reported[strtoupper($word)] = true;
                                }
                        }
                }
                
        }

}

class documentAcronymsHaveElement extends documentAbbrIsUsed {

        var $default_severity = QUAIL_TEST_MODERATE;

        var $acronym_tag = 'acronym';
}

class documentAllColorsAreSet extends quailTest {

        var $default_severity = QUAIL_TEST_SEVERE;

        var $cms = false;
                
        var $color_attributes = array('text', 'bgcolor', 'link', 'alink', 'vlink');
        
        function check() {
                $body = $this->getAllElements('body');
                $body = $body[0];
                if($body) {
                        $colors = 0;
                        foreach($this->color_attributes as $attribute) {
                                if($body->hasAttribute($attribute))
                                        $colors++;
                        }
                        if($colors > 0 && $colors < 5)
                                $this->addReport(null, null, false);
                }
        }
}

class documentAutoRedirectNotUsed extends quailTest {

        var $default_severity = QUAIL_TEST_SEVERE;

        var $cms = false;
        
        function check() {
                foreach($this->getAllElements('meta') as $meta) {
                        if($meta->getAttribute('http-equiv') == 'refresh' && !$meta->hasAttribute('content'))
                                $this->addReport($meta);
                }
        
        }
}

class documentColorWaiActiveLinkAlgorithim extends bodyWaiErtColorContrast {

        var $default_severity = QUAIL_TEST_SEVERE;

        var $cms = false;
        
        var $foreground = 'alink';
}

class documentColorWaiAlgorithim extends bodyWaiErtColorContrast {

        var $default_severity = QUAIL_TEST_SEVERE;

        var $cms = false;
                
}

class documentColorWaiLinkAlgorithim extends bodyWaiErtColorContrast {

        var $default_severity = QUAIL_TEST_SEVERE;

        var $cms = false;
        
        var $foreground = 'link';
}

class documentColorWaiVisitedLinkAlgorithim extends bodyWaiErtColorContrast {

        var $default_severity = QUAIL_TEST_SEVERE;

        var $cms = false;
        
        var $foreground = 'vlink';
}

class documentContentReadableWithoutStylesheets extends quailTest {

        var $default_severity = QUAIL_TEST_SUGGESTION;

        var $cms = false;
        
        function check() {
                foreach($this->getAllElements(null, 'text') as $text) {
                        if($text->hasAttribute('style')) {
                                $this->addReport(null, null, false);
                                return false;
                        }
                }
        
        }
}

class documentHasTitleElement extends quailTest {

        var $default_severity = QUAIL_TEST_SEVERE;

        var $cms = false;
        
        function check() {
                
                $element = $this->dom->getElementsByTagName('title');
                if(!$element->item(0))
                        $this->addReport(null, null, false);
        
        }
}

class documentIDsMustBeUnique extends quailTest {

        var $default_severity = QUAIL_TEST_SEVERE;

        var $cms = false;
                
        function check() {
                $xpath = new DOMXPath($this->dom);
                $entries = $xpath->query('//*');
                $ids = array();
                foreach($entries as $element) {
                        if($element->hasAttribute('id'))
                                $ids[$element->getAttribute('id')][] = $element;
                }       
                if(count($ids) > 0) {
                        foreach($ids as $id) {
                                if(count($id) > 1)
                                        $this->addReport($id[1]);
                        }
                }
        }
}

class documentLangIsISO639Standard extends quailTest {

        var $default_severity = QUAIL_TEST_SEVERE;

        var $cms = false;
        
        function check() {
                $languages = file(dirname(__FILE__).'/resources/iso639.txt');
                
                $element = $this->dom->getElementsByTagName('html');
                $html = $element->item(0);
                if(!$html)
                        return null;
                if($html->hasAttribute('lang'))
                        if(in_array(strtolower($html->getAttribute('lang')), $languages))
                                $this->addReport(null, null, false);
        
        }
}

class documentLangNotIdentified extends quailTest {

        var $default_severity = QUAIL_TEST_SEVERE;

        var $cms = false;
        
        function check() {
                $element = $this->dom->getElementsByTagName('html');
                $html = $element->item(0);
                if(!$html) return null;
                if(!$html->hasAttribute('lang') || trim($html->getAttribute('lang')) == '')
                        $this->addReport(null, null, false);
        
        }
}

class documentMetaNotUsedWithTimeout extends quailTest {

        var $default_severity = QUAIL_TEST_SEVERE;

        var $cms = false;
        
        function check() {
                foreach($this->getAllElements('meta') as $meta) {
                        if($meta->getAttribute('http-equiv') == 'refresh' && !$meta->getAttribute('content'))
                                $this->addReport($meta);
                }
        
        }
}

class documentReadingDirection extends quailTest {


        var $default_severity = QUAIL_TEST_MODERATE;

        var $cms = false;
        
        var $right_to_left = array('he', 'ar');
        
        function check() {
                $xpath = new DOMXPath($this->dom);
                $entries = $xpath->query('//*');
                foreach($entries as $element) {
                        if(in_array($element->getAttribute('lang'), $this->right_to_left)) {

                                if($element->getAttribute('dir') != 'rtl')
                                        $this->addReport($element);
                        }
                }                       
        }
}

class documentStrictDocType extends quailTest {

        var $default_severity = QUAIL_TEST_SEVERE;

        var $cms = false;
        
        function check() {
                if(strpos(strtolower($this->dom->doctype->publicId), 'strict') === false
                   && strpos(strtolower($this->dom->doctype->systemId), 'strict') === false) 
                        $this->addReport(null, null, false);
        }
}

class documentTitleDescribesDocument extends quailTest {

        var $default_severity = QUAIL_TEST_SUGGESTION;

        var $cms = false;
        
        function check() {
                $placeholders = file(dirname(__FILE__).'/resources/placeholder.txt');           
                $element = $this->dom->getElementsByTagName('title');
                $title = $element->item(0);
                if($title) {
                                $this->addReport($title);
                }
        }
}

class documentTitleIsNotPlaceholder extends quailTest {

        var $default_severity = QUAIL_TEST_SEVERE;

        var $cms = false;
        
        function check() {
                $placeholders = file(dirname(__FILE__).'/resources/placeholder.txt');           
                $element = $this->dom->getElementsByTagName('title');
                $title = $element->item(0);
                if($title) {
                        if(in_array(strtolower($title->nodeValue), $placeholders))
                                $this->addReport(null, null, false);
                }
        }
}

class documentTitleIsShort extends quailTest {

        var $default_severity = QUAIL_TEST_MODERATE;

        var $cms = false;
        
        function check() {
                
                $element = $this->dom->getElementsByTagName('title');
                $title = $element->item(0);
                if($title) {
                        if(strlen($title->nodeValue)> 150)
                                $this->addReport(null, null, false);
                }
        }
}

class documentTitleNotEmpty extends quailTest {

        var $default_severity = QUAIL_TEST_SEVERE;

        var $cms = false;
        
        function check() {
                
                $element = $this->dom->getElementsByTagName('title');
                if($element->length > 0) {
                        $title = $element->item(0);
                        if(trim($title->nodeValue) == '')
                                $this->addReport(null, null, false);
                }       
        }
}

class documentValidatesToDocType extends quailTest {

        var $default_severity = QUAIL_TEST_SEVERE;

        var $cms = false;
        
        function check() {
                if(!@$this->dom->validate())
                        $this->addReport(null, null, false);
        }
}

class documentVisualListsAreMarkedUp extends quailTest {

        var $default_severity = QUAIL_TEST_SEVERE;

        var $list_cues = array('*', '<br>*', '•', '&#8226');
        
        function check() {
                foreach($this->getAllElements(null, 'text') as $text) {
                        foreach($this->list_cues as $cue) {
                                $first = stripos($text->nodeValue, $cue);
                                $second = strripos($text->nodeValue, $cue);
                                if($first && $second && $first != $second)
                                        $this->addReport($text);
                        }
                }
        
        }
}

class documentWordsNotInLanguageAreMarked extends quailTest {

        var $default_severity = QUAIL_TEST_SUGGESTION;

        function check() {
                $body = $this->getAllElements('body');
                if(!isset($body[0])) {
                        return false;
                }
                $body = $body[0];
                if(!is_object($body)) {
                        return false;
                }
                if(!property_exists($body, 'nodeValue')) {
                        return false;
                }
                $words = explode(' ', $body->nodeValue);

                if(count($words) > 10)
                        $this->addReport(null, null, false);
        }
}

class embedHasAssociatedNoEmbed extends quailTest {

        var $default_severity = QUAIL_TEST_SEVERE;

        function check() {
                foreach($this->getAllElements('embed') as $embed) {
                        if(!$this->propertyIsEqual($embed->firstChild, 'tagName', 'noembed') 
                           && !$this->propertyIsEqual($embed->nextSibling, 'tagName', 'noembed')) {
                                        $this->addReport($embed);
                        }
                
                }
        }
}

class embedMustHaveAltAttribute extends quailTest {

        var $default_severity = QUAIL_TEST_SEVERE;

        function check() {
                foreach($this->getAllElements('embed') as $embed) {
                        if(!$embed->hasAttribute('alt'))
                                        $this->addReport($embed);
                
                }
        }
}

class embedMustNotHaveEmptyAlt extends quailTest {

        var $default_severity = QUAIL_TEST_SEVERE;

        function check() {
                foreach($this->getAllElements('embed') as $embed) {
                        if($embed->hasAttribute('alt') && trim($embed->getAttribute('alt')) == '')
                                        $this->addReport($embed);
                
                }
        }
}

class embedProvidesMechanismToReturnToParent extends quailTagTest {

        var $default_severity = QUAIL_TEST_SUGGESTION;

        var $tag = 'embed';
}

class emoticonsExcessiveUse extends quailTest {

        var $default_severity = QUAIL_TEST_SEVERE;

        function check() {
                $emoticons = file(dirname(__FILE__).'/resources/emoticons.txt', FILE_IGNORE_NEW_LINES);
                $count = 0;
                foreach($this->getAllElements(null, 'text') as $element) {
                        if(strlen($element->nodeValue < 2)) {
                                $words = explode(' ', $element->nodeValue);
                                foreach($words as $word) {
                                        if(in_array($word, $emoticons)) {
                                                $count++;
                                                if($count > 4) {
                                                        $this->addReport(null, null, false);    
                                                        return false;   
                                                }
                                        }
                                }
                        
                        }
                }
        
        }
}

class emoticonsMissingAbbr extends quailTest {

        var $default_severity = QUAIL_TEST_SEVERE;

        function check() {
                $emoticons = file(dirname(__FILE__).'/resources/emoticons.txt', FILE_IGNORE_NEW_LINES);
                $count = 0;
                foreach($this->getAllElements('abbr') as $abbr) {
                        $abbreviated[$abbr->nodeValue] = $abbr->getAttribute('title');
                }
                foreach($this->getAllElements(null, 'text') as $element) {
                        if(strlen($element->nodeValue < 2)) {
                                $words = explode(' ', $element->nodeValue);
                                foreach($words as $word) {
                                        if(in_array($word, $emoticons)) {
                                                if(!isset($abbreviated[$word]))
                                                        $this->addReport($element);
                                        }
                                }
                        
                        }
                }
        
        }
}

class fileHasLabel extends inputHasLabel {

        var $default_severity = QUAIL_TEST_SEVERE;

        var $tag = 'input';
        
        var $type = 'file';

        var $no_type = false;
}

class fileLabelIsNearby extends quailTest {

        var $default_severity = QUAIL_TEST_MODERATE;

        function check() {
                foreach($this->getAllElements('input') as $input) {
                        if($input->getAttribute('type') == 'file')
                                $this->addReport($input);
                        
                }
        }
}

class fontIsNotUsed extends quailTagTest {

        var $default_severity = QUAIL_TEST_SEVERE;
        
        var $tag = 'font';
}

class formAllowsCheckIfIrreversable extends quailTagTest {

        var $default_severity = QUAIL_TEST_SUGGESTION;

        var $tag = 'form';
}

class formDeleteIsReversable extends quailTest {

        var $default_severity = QUAIL_TEST_SUGGESTION;
        
        var $strings = array('en' => array('delete', 'remove', 'erase'),
                                                         'es' => array('borrar', 'eliminar', 'suprimir'),
                                                        );
        
        function check() {
                foreach($this->getAllElements('input') as $input) {
                        if($input->getAttribute('type') == 'submit') {
                                foreach($this->translation() as $word) {
                                        if(strpos(strtolower($input->getAttribute('value')), $word) !== false) 
                                                $this->addReport($this->getParent($input, 'form', 'body'));
                                }                               
                        }
                }
        }
}

class formErrorMessageHelpsUser extends quailTagTest {

        var $default_severity = QUAIL_TEST_SUGGESTION;

        var $tag = 'form';
}

class formHasGoodErrorMessage extends quailTagTest {

        var $default_severity = QUAIL_TEST_SUGGESTION;

        var $tag = 'form';
}       


class formWithRequiredLabel extends quailTest {

        var $default_severity = QUAIL_TEST_MODERATE;
        
        var $suspect_styles = array('font-weight', 'color');
        
        function check() {
                $labels = array();
                foreach($this->getAllElements('label') as $label) {
                        $labels[] = $label;
                        if(strpos($label->nodeValue, '*') !== false) {
                                if($input = $this->dom->getElementById($label->getAttribute('for'))) {
                                        if(!$input->hasAttribute('aria-required') || 
                                           strtolower($input->getAttribute('aria-required')) != 'true') {
                                                 $this->addReport($label);
                                        }
                                }
                                else {
                                        $this->addReport($label);
                                }
                        }
                }
                $styles = array();
                foreach($labels as $k => $label) {
                        //Now we check through all the labels and see if any are 
                        //colored different than the others
                        $styles[$k] = $this->css->getStyle($label);
                        if($this->elementHasChild($label, 'strong') || $this->elementHasChild($label, 'b')) {
                                $styles[$k]['font-weight'] = 'bold';
                        }
                        if($k) {
                                foreach($this->suspect_styles as $style) {
                                        if($styles[$k][$style] != $styles[($k - 1)][$style]) {
                                                $form = $this->getElementAncestor($label, 'form');
                                                if($form) {
                                                        $this->addReport($form);
                                                }
                                                else {
                                                        $this->addReport($label);
                                                }
                                        }
                                }
                        }
                }
        }
}

class frameIsNotUsed extends quailTagTest {

        var $default_severity = QUAIL_TEST_SEVERE;

        var $tag = 'frame';

        var $cms = false;
        
}

class frameRelationshipsMustBeDescribed extends quailTest {

        var $default_severity = QUAIL_TEST_MODERATE;

        var $cms = false;
                
        
        function check() {
                foreach($this->getAllElements('frameset') as $frameset) {
                
                        if(!$frameset->hasAttribute('longdesc') && $frameset->childNodes->length > 2)
                                $this->addReport($frameset);
                }
        }

}

class frameSrcIsAccessible extends quailTest {

        var $default_severity = QUAIL_TEST_SUGGESTION;

        var $cms = false;
                
        function check() {
                foreach($this->getAllElements('frame') as $frame) {
                        if($frame->hasAttribute('src')) {
                                $extension = array_pop(explode('.', $frame->getAttribute('src')));
                                if(in_array($extension, $this->image_extensions))
                                        $this->addReport($frame);
                        
                        }
                }
        }

}

class frameTitlesDescribeFunction extends quailTest {

        var $default_severity = QUAIL_TEST_SUGGESTION;  

        var $cms = false;
                
        function check() {
                foreach($this->getAllElements('frame') as $frame) {
                        if($frame->hasAttribute('title'))
                                $this->addReport($frame);
                }
        }

}

class frameTitlesNotEmpty extends quailTest {

        var $default_severity = QUAIL_TEST_SEVERE;

        var $cms = false;
        
        function check() {
                foreach($this->getAllElements('frame') as $frame) {
                        if(!$frame->hasAttribute('title') || trim($frame->getAttribute('title')) == '')
                                $this->addReport($frame);
                }
        }
}

class frameTitlesNotPlaceholder extends quailTest {

        var $default_severity = QUAIL_TEST_SEVERE;

        var $cms = false;
        
        var $strings = array('en' => array('title', 'frame', 'frame title', 'the title'),
                                                          'es' => array('t&iacute;tulo', 'marco', 't&iacute;tulo del marco', 'el t&iacute;tulo'),
                                                          );
        
        function check() {
                foreach($this->getAllElements('frame') as $frame) {
                        if(in_array(trim(strtolower($frame->getAttribute('title'))), $this->translation()))
                                $this->addReport($frame);
                }
        }

}

class framesHaveATitle extends quailTest {

        var $default_severity = QUAIL_TEST_SEVERE;      
        
        var $cms = false;
        
        function check() {
                foreach($this->getAllElements('frame') as $frame) {
                        if(!$frame->hasAttribute('title'))
                                $this->addReport($frame);
                }
        }

}

class framesetIsNotUsed extends quailTagTest {

        var $default_severity = QUAIL_TEST_SEVERE;

        var $cms = false;
        
        var $tag = 'frameset';
}

class framesetMustHaveNoFramesSection extends quailTest {

        var $default_severity = QUAIL_TEST_SEVERE;

        var $cms = false;
                
        function check() {
                foreach($this->getAllElements('frameset') as $frameset) {
                        if(!$this->elementHasChild($frameset, 'noframes'))
                                $this->addReport($frameset);
                }
        }

}

class headerH1 extends quailHeaderTest {
        
        var $tag = 'h1';
        
}

class headerH1Format extends quailTagTest{

        var $default_severity = QUAIL_TEST_SUGGESTION;

        var $tag = 'h1';
}

class headerH2 extends quailHeaderTest {
        
        var $tag = 'h2';
        
}

class headerH2Format extends quailTagTest{

        var $default_severity = QUAIL_TEST_SUGGESTION;
        
        var $tag = 'h2';
}

class headerH3 extends quailHeaderTest {
        
        var $tag = 'h3';
        
}

class headerH3Format extends quailTagTest{

        var $default_severity = QUAIL_TEST_SUGGESTION;
        
        var $tag = 'h3';
}

class headerH4 extends quailHeaderTest {
        
        var $tag = 'h4';
        
}

class headerH4Format extends quailTagTest{

        var $default_severity = QUAIL_TEST_SUGGESTION;

        var $tag = 'h4';
}

class headerH5 extends quailHeaderTest {
        
        var $tag = 'h5';
        
}

class headerH5Format extends quailTagTest{

        var $default_severity = QUAIL_TEST_SUGGESTION;

        var $tag = 'h5';
}

class headerH6Format extends quailTagTest{

        var $default_severity = QUAIL_TEST_SUGGESTION;

        var $tag = 'h6';
}

class headersUseToMarkSections extends quailTest {

        var $default_severity = QUAIL_TEST_MODERATE;
        
        var $non_header_tags = array('strong', 'b', 'em', 'i');
        
        function check() {
                $headers = $this->getAllElements(null, 'header');
                $paragraphs = $this->getAllElements('p');
                if(count($headers) == 0 && count($paragraphs) > 1)
                        $this->addReport(null, null, false);
                foreach($paragraphs as $p) {
                        if((is_object($p->firstChild) 
                                                && property_exists($p->firstChild, 'tagName') 
                                                && in_array($p->firstChild->tagName, $this->non_header_tags)
                                                && trim($p->nodeValue) == trim($p->firstChild->nodeValue))
                           || (is_object($p->firstChild->nextSibling)
                                                && property_exists($p->firstChild->nextSibling, 'tagName') 
                                                && in_array($p->firstChild->nextSibling->tagName, $this->non_header_tags)
                                                && trim($p->nodeValue) == trim($p->firstChild->nextSibling->nodeValue))
                           || (is_object($p->previousSibling)
                                                && property_exists($p->previousSibling, 'tagName')
                                                && in_array($p->previousSibling->tagName, $this->non_header_tags)
                                                && trim($p->nodeValue) == trim($p->previousSibling->nodeValue)))
                                $this->addReport($p);
                }
        }
}

class iIsNotUsed extends quailTagTest {

        var $default_severity = QUAIL_TEST_SEVERE;

        var $tag = 'i';
}

class iframeMustNotHaveLongdesc extends quailTest {

        var $default_severity = QUAIL_TEST_SEVERE;

        function check() {
                foreach($this->getAllElements('iframe') as $iframe) {
                        if($iframe->hasAttribute('longdesc'))
                                $this->addReport($iframe);
                
                }
        }
}

class imageMapServerSide extends quailTest {

        var $default_severity = QUAIL_TEST_SEVERE;

        function check() {
                foreach($this->getAllElements('img') as $img) {
                        if($img->hasAttribute('ismap'))
                                $this->addReport($img);
                }
        
        }
}

class imgAltEmptyForDecorativeImages extends quailTest {

        var $default_severity = QUAIL_TEST_SUGGESTION;

        function check() {
                foreach($this->getAllElements('img') as $img) {
                        if($img->hasAttribute('alt'))
                                $this->addReport($img);
                }
        }

}

class imgAltIdentifiesLinkDestination extends quailTest {

        var $default_severity = QUAIL_TEST_SUGGESTION;
        
        function check() {
                foreach($this->getAllElements('a') as $a) {
                        if(!$a->nodeValue) {
                                foreach($a->childNodes as $child) {
                                        if($this->propertyIsEqual($child, 'tagName', 'img') 
                                           && $child->hasAttribute('alt')) {
                                                $this->addReport($child);
                                        }
                                }
                        }
                }
        
        }
}

class imgAltIsDifferent extends quailTest {

        var $default_severity = QUAIL_TEST_SEVERE;

        function check() {
                foreach($this->getAllElements('img') as $img) {
                        if(trim($img->getAttribute('src')) == trim($img->getAttribute('alt')))
                                $this->addReport($img);
                }
        }

}

class imgAltIsSameInText extends quailTest {

        var $default_severity = QUAIL_TEST_SUGGESTION;
        
        function check() {
                foreach($this->getAllElements('img') as $img) {
                        if($img->hasAttribute('alt'))
                                $this->addReport($img);
                }
        
        }
}

class imgAltIsTooLong extends quailTest {

        var $default_severity = QUAIL_TEST_SEVERE;

        function check() {
                foreach($this->getAllElements('img') as $img) {
                        if($img->hasAttribute('alt') && strlen($img->getAttribute('alt')) > 100) 
                                $this->addReport($img);
                }
        
        }
}

class imgAltNotEmptyInAnchor extends quailTest {

        var $default_severity = QUAIL_TEST_SEVERE;

        function check() {
                foreach($this->getAllElements('a') as $a) {
                        if(!$a->nodeValue && $a->childNodes) {
                                foreach($a->childNodes as $child) {
                                        if($this->propertyIsEqual($child, 'tagName', 'img')
                                                && trim($child->getAttribute('alt')) == '')
                                                        $this->addReport($child);
                                }
                        }
                }
        
        }
}

class imgAltNotPlaceHolder extends quailTest {

        var $default_severity = QUAIL_TEST_SEVERE;
        
        var $strings = array('en' => array('nbsp', '&nbsp;', 'spacer', 'image', 'img', 'photo'),
                                                 'es' => array('nbsp', '&nbsp;', 'spacer', 'espacio', 'imagen', 'img', 'foto')
                                                 );
        
        function check() {
                foreach($this->getAllElements('img') as $img) {
                        if($img->hasAttribute('alt')) {
                                if(strlen($img->getAttribute('alt')) > 0) {
                                        if(in_array($img->getAttribute('alt'), $this->translation()) 
                                           || ord($img->getAttribute('alt')) == 194) {
                                                $this->addReport($img);
                                        }
                                        elseif(preg_match("/^([0-9]*)(k|kb|mb|k bytes|k byte)?$/", 
                                                        strtolower($img->getAttribute('alt')))) {
                                                $this->addReport($img);
                                        }
                                }
                        }
                }
        
        }
}

class imgGifNoFlicker extends quailTest {

        var $default_severity = QUAIL_TEST_SEVERE;
        
        var $gif_control_extension = "/21f904[0-9a-f]{2}([0-9a-f]{4})[0-9a-f]{2}00/";
        
        function check() {
                foreach($this->getAllElements('img') as $img) {
                        
                        if(substr($img->getAttribute('src'), -4, 4) == '.gif') {
                                $file = $this->getImageContent($this->getPath($img->getAttribute('src')));
                                if($file) {
                                          $file = bin2hex($file);
                                        
                                          // sum all frame delays
                                          $total_delay = 0;
                                          preg_match_all($this->gif_control_extension, $file, $matches);
                                          foreach ($matches[1] as $match) {
                                            // convert little-endian hex unsigned ints to decimals
                                            $delay = hexdec(substr($match,-2) . substr($match, 0, 2));
                                            if ($delay == 0) $delay = 1;
                                            $total_delay += $delay;
                                          }
                                        
                                          // delays are stored as hundredths of a second, lets convert to seconds
                                          
                                         
                                         if($total_delay > 0)
                                                $this->addReport($img);
                                }
                        }
                }
        
        }
        
        function getImageContent($image) {
                if(strpos($image, '://') == false) {
                        return @file_get_contents($image);
                }
                if(function_exists('curl')) {
                        $curl = new curl_init($image);
                        curl_setopt($curl, CURLOPT_RETURNTRANSFER, true);
                        $result = curl_exec($curl);
                        return $result;
                }
                return false;
        }
}

class imgHasAlt extends quailTest {

        var $default_severity = QUAIL_TEST_SEVERE;

        function check() {
                foreach($this->getAllElements('img') as $img) {
                        if(!$img->hasAttribute('alt'))
                                $this->addReport($img);
                }
        
        }
}

class imgHasLongDesc extends quailTest {

        var $default_severity = QUAIL_TEST_SEVERE;

        function check() {
                foreach($this->getAllElements('img') as $img) {
                        if($img->hasAttribute('longdesc')) {
                                if(trim(strtolower($img->getAttribute('longdesc'))) == 
                                        trim(strtolower($img->getAttribute('alt')))) {
                                                $this->addReport($img);
                                }
                        }
                }
        
        }
}

class imgImportantNoSpacerAlt extends quailTest {

        var $default_severity = QUAIL_TEST_SEVERE;

        function check() {
                foreach($this->getAllElements('img') as $img) {
                        if($img->hasAttribute('src') && $img->hasAttribute('alt') && trim($img->getAttribute('alt')) == '') {
                                if($img->getAttribute('width') > 25 || $img->getAttribute('height') > 25) {
                                        $this->addReport($img);
                                }
                                elseif(function_exists('gd_info') && (!$img->hasAttribute('width') || !$img->hasAttribute('height'))) {                 
                                        $img_file = @getimagesize($this->getPath($img->getAttribute('src')));
                                        if($img_file) {
                                                if($img_file[0] > 25 || $img_file[1] > 25)
                                                        $this->addReport($img);
                                        }
                                }
                        }

                }
        
        }
}

class imgMapAreasHaveDuplicateLink extends quailTest {

        var $default_severity = QUAIL_TEST_SEVERE;
        
        function check() {
                $all_links = array();
                foreach($this->getAllElements('a') as $a) {
                        $all_links[$a->getAttribute('href')] = $a->getAttribute('href');
                }
                $maps = $this->getElementsByAttribute('map', 'name', true);
                
                foreach($this->getAllElements('img') as $img) {
                        if($img->hasAttribute('usemap')) {
                                $usemap = $img->getAttribute('usemap');
                                if(substr($usemap, 0, 1) == '#') {
                                        $key = substr($usemap, -(strlen($usemap) - 1), (strlen($usemap) - 1));
                                }
                                else {
                                        $key = $usemap;
                                }
                                if(isset($maps[$key])) {
                                        foreach($maps[$key]->childNodes as $child) {
                                                if($this->propertyIsEqual($child, 'tagName', 'area')) {
                                                        if(!isset($all_links[$child->getAttribute('href')])) {
                                                                $this->addReport($img);
                                                        }
                                                }
                                        }
                                }
                        }
                }
        
        }
}

class imgNeedsLongDescWDlink extends quailTest {

        var $default_severity = QUAIL_TEST_SEVERE;

        function check() {
                foreach($this->getAllElements('img') as $img) {
                        if($img->hasAttribute('longdesc')) {
                                $next = $this->getNextElement($img);
                                
                                if(is_object($next) && $next->tagName != 'a') {
                                        $this->addReport($img);
                                }
                                else {
                                        if(((!$this->propertyIsEqual($next, 'nodeValue', '[d]', true, true) 
                                                        && !$this->propertyIsEqual($next, 'nodeValue', 'd', true, true)) )
                                                || $next->getAttribute('href') != $img->getAttribute('longdesc')) {
                                                        $this->addReport($img);
                                        }
                                }
                                        
                        }
                }
        
        }
}

class imgNonDecorativeHasAlt extends quailTest {

        var $default_severity = QUAIL_TEST_MODERATE;

        function check() {
                foreach($this->getAllElements('img') as $img) {
                        if($img->hasAttribute('src') && 
                                ($img->hasAttribute('alt') && html_entity_decode((trim($img->getAttribute('alt')))) == '')) {
                                $this->addReport($img);
                                
                        }
                }
        
        }
}

class imgNotReferredToByColorAlone extends quailTest {

        var $default_severity = QUAIL_TEST_SUGGESTION;
        
        function check() {
                foreach($this->getAllElements('img') as $img) {
                        if($img->hasAttribute('alt'))
                                $this->addReport($img);
                }
        
        }
}

class imgServerSideMapNotUsed extends quailTest {

        var $default_severity = QUAIL_TEST_SEVERE;

        function check() {
                foreach($this->getAllElements('img') as $img) {
                        if($img->hasAttribute('ismap'))
                                $this->addReport($img);
                }
        }
}

class imgShouldNotHaveTitle extends quailTest {

        var $default_severity = QUAIL_TEST_SEVERE;

        function check() {
                foreach($this->getAllElements('img') as $img) {
                        if($img->hasAttribute('title'))
                                $this->addReport($img);
                }
        
        }
}

class imgWithMapHasUseMap extends quailTest {

        var $default_severity = QUAIL_TEST_SEVERE;
        
        function check() {
                foreach($this->getAllElements('img') as $img) {
                        if($img->hasAttribute('ismap') && !$img->hasAttribute('usemap'))
                                $this->addReport($img);
                }
        
        }
}

class imgWithMathShouldHaveMathEquivalent extends quailTest {

        var $default_severity = QUAIL_TEST_SUGGESTION;

        function check() {
                foreach($this->getAllElements('img') as $img) {
                        if(($img->getAttribute('width') > 100 
                                || $img->getAttribute('height') > 100 )
                                && (!$this->propertyIsEqual($img->nextSibling, 'tagName', 'math'))) {
                                                        $this->addReport($img);
                        }
                
                }
        }
}

class inputCheckboxHasTabIndex extends inputTabIndex {

        var $default_severity = QUAIL_TEST_SEVERE;
        
        var $tag = 'input';
        
        var $type = 'checkbox';
}

class inputCheckboxRequiresFieldset extends quailTest {

        var $default_severity = QUAIL_TEST_SEVERE;

        function check() {
                foreach($this->getAllElements('input') as $input) {
                        if($input->getAttribute('type') == 'checkbox') {
                                if(!$this->getParent($input, 'fieldset', 'body'))
                                        $this->addReport($input);
                                
                        }
                }
        }
}

class inputDoesNotUseColorAlone extends quailTest {

        var $default_severity = QUAIL_TEST_SUGGESTION;

        function check() {
                foreach($this->getAllElements('input') as $input) {
                        if($input->getAttribute('type') != 'hidden')
                                $this->addReport($input);
                }
        }

}

class inputElementsDontHaveAlt extends quailTest {

        var $default_severity = QUAIL_TEST_SEVERE;

        function check() {
                foreach($this->getAllElements('input') as $input) {
                        if($input->getAttribute('type') != 'image' && $input->hasAttribute('alt'))
                                $this->addReport($input);
                }
        }
}

class inputFileHasTabIndex extends inputTabIndex {

        var $default_severity = QUAIL_TEST_SEVERE;

        var $tag = 'input';
        
        var $type = 'file';
}

class inputImageAltIdentifiesPurpose extends quailTest {

        var $default_severity = QUAIL_TEST_SUGGESTION;

        function check() {
                foreach($this->getAllElements('input') as $input) {
                        if($input->getAttribute('type') == 'image')
                                $this->addReport($input);
                }
        }

}

class inputImageAltIsNotFileName extends quailTest {

        var $default_severity = QUAIL_TEST_SEVERE;

        function check() {
                foreach($this->getAllElements('input') as $input) {
                        if($input->getAttribute('type') == 'image' 
                                && strtolower($input->getAttribute('alt')) == strtolower($input->getAttribute('src')))
                                        $this->addReport($input);
                }
        }

}

class inputImageAltIsNotPlaceholder extends imgAltNotPlaceHolder {

        var $default_severity = QUAIL_TEST_SEVERE;
        
        function check() {
                foreach($this->getAllElements('input') as $input) {
                        if($input->getAttribute('type') == 'image') {
                                if(in_array($input->getAttribute('alt'), $this->translation()) || ord($input->getAttribute('alt')) == 194) {
                                        $this->addReport($input);
                                }
                                elseif(preg_match("/^([0-9]*)(k|kb|mb|k bytes|k byte)?$/", strtolower($input->getAttribute('alt')))) {
                                        $this->addReport($input);
                                }
                        }
                }
        
        }
}

class inputImageAltIsShort extends quailTest {

        var $default_severity = QUAIL_TEST_SEVERE;

        function check() {
                foreach($this->getAllElements('input') as $input) {
                        if($input->getAttribute('type') == 'image' && strlen($input->getAttribute('alt')) > 100)
                                $this->addReport($input);
                }
        }

}

class inputImageAltNotRedundant extends quailTest {

        var $default_severity = QUAIL_TEST_SEVERE;

        var $strings = array('en' => array('submit', 'button'),
                                                           'es' => array('enviar', 'bot&oacute;n'),
                                                          );

        function check() {
                foreach($this->getAllElements('input') as $input) {
                        if($input->getAttribute('type') == 'image') {
                                foreach($this->translation() as $word) {
                                        if(strpos($input->getAttribute('alt'), $word) !== false)
                                                        $this->addReport($input);
                                }
                        }
                }
        }
}

class inputImageHasAlt extends quailTest {

        var $default_severity = QUAIL_TEST_SEVERE;

        function check() {
                foreach($this->getAllElements('input') as $input) {
                        if($input->getAttribute('type') == 'image' 
                                        && (trim($input->getAttribute('alt')) == '' || !$input->hasAttribute('alt')))
                                $this->addReport($input);
                }
        }

}

class inputImageNotDecorative extends quailTest {

        var $default_severity = QUAIL_TEST_SUGGESTION;

        function check() {
                foreach($this->getAllElements('input') as $input) {
                        if($input->getAttribute('type') == 'image')
                                $this->addReport($input);
                }
        }
}

class inputPasswordHasTabIndex extends inputTabIndex {

        var $default_severity = QUAIL_TEST_SEVERE;
        
        var $tag = 'input';
        
        var $type = 'password';
}

class inputRadioHasTabIndex extends inputTabIndex {

        var $default_severity = QUAIL_TEST_SEVERE;
        
        var $tag = 'input';
        
        var $type = 'radio';
}

class inputSubmitHasTabIndex extends inputTabIndex {

        var $default_severity = QUAIL_TEST_SEVERE;
        
        var $tag = 'input';
        
        var $type = 'submit';
}

class inputTextHasLabel extends inputHasLabel {

        var $default_severity = QUAIL_TEST_SEVERE;
        
        var $tag = 'input';
        
        var $type = 'text';
        
        var $no_type = false;
}

class inputTextHasTabIndex extends inputTabIndex {

        var $default_severity = QUAIL_TEST_SEVERE;

        var $tag = 'input';
        
        var $type = 'text';
}

class inputTextHasValue extends quailTest {

        var $default_severity = QUAIL_TEST_SEVERE;
        

        function check() {
                foreach($this->getAllElements('input') as $input) {
                        if($input->getAttribute('type') == 'text' && !$input->hasAttribute('value'))
                                $this->addReport($input);       
                        
                }
        
        }
}

class inputTextValueNotEmpty extends quailTest {

        var $default_severity = QUAIL_TEST_SEVERE;
        
        function check() {
                foreach($this->getAllElements('input') as $input) {
                        if(!$input->hasAttribute('value') || trim($input->getAttribute('value')) == '')
                                        $this->addReport($input);
                        
                }
        }
}

class labelDoesNotContainInput extends quailTest {

        var $default_severity = QUAIL_TEST_SEVERE;

        function check() {
                foreach($this->getAllElements('label') as $label) {
                        if($this->elementHasChild($label, 'input') || $this->elementHasChild($label, 'textarea'))
                                $this->addReport($label);
                }
        }
}

class labelMustBeUnique extends quailTest {

        var $default_severity = QUAIL_TEST_SEVERE;
        
        function check() {
                $labels = array();
                foreach($this->getAllElements('label') as $label) {
                        if($label->hasAttribute('for'))
                                $labels[$label->getAttribute('for')][] = $label;
                }
                foreach($labels as $label) {
                        if(count($label) > 1)
                                $this->addReport($label[1]);
                }
        }
}

class labelMustNotBeEmpty extends quailTest {

        var $default_severity = QUAIL_TEST_SEVERE;

        function check() {
                foreach($this->getAllElements('label') as $label) {
                        if(!$this->elementContainsReadableText($label)) {
                                $this->addReport($label);
                        }
                }
        }
}

class legendDescribesListOfChoices extends quailTagTest {

        var $default_severity = QUAIL_TEST_SUGGESTION;

        var $tag = 'legend';
}

class legendTextNotEmpty extends quailTest {

        var $default_severity = QUAIL_TEST_SEVERE;

        function check() {
                foreach($this->getAllElements('legend') as $legend) {
                        if(!$legend->nodeValue || trim($legend->nodeValue) == '')
                                $this->addReport($legend);
                }
        }
}

class legendTextNotPlaceholder extends quailTest {

        var $default_severity = QUAIL_TEST_SEVERE;

        var $strings = array('en' => array('&nbsp;', ' ', 'legend'),
                                                 'es' => array('&nbsp;', ' ', 'relato'),
                                                );
        
        function check() {
                foreach($this->getAllElements('legend') as $legend) {
                        if(in_array(trim($legend->nodeValue), $this->translation()))
                                $this->addReport($legend);
                }
        }

}

class liDontUseImageForBullet extends quailTest {

        var $default_severity = QUAIL_TEST_MODERATE;

        function check() {
                foreach($this->getAllElements('li') as $li) {
                        if(!$this->propertyIsEqual($li, 'nodeValue', '', true) 
                           && $this->propertyIsEqual($li->firstChild, 'tagName', 'img')) {
                                        $this->addReport($li);
                        }
                }
        
        }
}

class linkUsedForAlternateContent extends quailTest {

        var $default_severity = QUAIL_TEST_SUGGESTION;

        function check() {
                $head = $this->getAllElements('head');
                $head = $head[0];
                if($head && property_exists($head, 'childNodes')) {
                        foreach($head->childNodes as $child) {
                                if($this->propertyIsEqual($child, 'tagName', 'link') && $child->getAttribute('rel') == 'alternate')
                                        return true;
                        }
                }
                $this->addReport(null, null, false);
        }
}




class linkUsedToDescribeNavigation extends quailTest {

        var $default_severity = QUAIL_TEST_SEVERE;

        function check() {
                $head = $this->getAllElements('head');
                $head = $head[0];
                if($head->childNodes) {
                        foreach($head->childNodes as $child) {
                                if($this->propertyIsEqual($child, 'tagName', 'link') && $child->getAttribute('rel') != 'stylesheet')
                                        return true;
                        }
                        $this->addReport(null, null, false);
                }
        }
}

class listNotUsedForFormatting extends quailTest {

        var $default_severity = QUAIL_TEST_SUGGESTION;

        function check() {
                foreach($this->getAllElements(array('ul', 'ol')) as $list) {
                        $li_count = 0;
                        foreach($list->childNodes as $child) {
                                if($this->propertyIsEqual($child, 'tagName', 'li')) {
                                        $li_count++;
                                }
                        }
                        if($li_count < 2)
                                $this->addReport($list);
                }
        
        }
}

class marqueeIsNotUsed extends quailTagTest {

        var $default_severity = QUAIL_TEST_SEVERE;
        
        var $tag = 'marquee';

}

class menuNotUsedToFormatText extends quailTest {

        var $default_severity = QUAIL_TEST_SUGGESTION;

        function check() {
                foreach($this->getAllElements('menu') as $menu) {
                        $list_items = 0;
                        foreach($menu->childNodes as $child) {
                                if($this->propertyIsEqual($child, 'tagName', 'li')) {
                                        $list_items++;
                                }
                        }
                        if($list_items == 1)
                                $this->addReport($menu);
                }
        
        }
}

class noembedHasEquivalentContent extends quailTagTest {

        var $default_severity = QUAIL_TEST_SUGGESTION;

        var $tag = 'noembed';
}

class noframesSectionMustHaveTextEquivalent extends quailTest {

        var $default_severity = QUAIL_TEST_MODERATE;    
        
        function check() {
                foreach($this->getAllElements('frameset') as $frameset) {
                        if(!$this->elementHasChild($frameset, 'noframes'))
                                $this->addReport($frameset);
                }
                foreach($this->getAllElements('noframes') as $noframes) {
                        $this->addReport($noframes);
                }
        }

}

class objectContentUsableWhenDisabled extends quailTagTest {

        var $default_severity = QUAIL_TEST_SUGGESTION;

        var $tag = 'object';
}

class objectDoesNotFlicker extends quailTagTest {

        var $default_severity = QUAIL_TEST_SUGGESTION;

        var $tag = 'object';

}

class objectDoesNotUseColorAlone extends quailTagTest {

        var $default_severity = QUAIL_TEST_SUGGESTION;

        var $tag = 'object';
}

class objectInterfaceIsAccessible extends quailTagTest {

        var $default_severity = QUAIL_TEST_SUGGESTION;

        var $tag = 'object';
}

class objectLinkToMultimediaHasTextTranscript extends quailTest {

        var $default_severity = QUAIL_TEST_SUGGESTION;

        function check() {
                foreach($this->getAllElements('object') as $object) {
                        if($object->getAttribute('type') == 'video')
                                $this->addReport($object);
                        
                }
        }

}

class objectMustContainText extends quailTest {

        var $default_severity = QUAIL_TEST_SEVERE;

        function check() {
                foreach($this->getAllElements('object') as $object) {
                        if(!$object->nodeValue || trim($object->nodeValue) == '')
                                $this->addReport($object);
                
                }
        }
}

class objectMustHaveEmbed extends quailTest {

        var $default_severity = QUAIL_TEST_SEVERE;

        function check() {
                foreach($this->getAllElements('object') as $object) {
                        if(!$this->elementHasChild($object, 'embed'))
                                $this->addReport($object);
                }
        }
}

class objectMustHaveTitle extends quailTest {

        var $default_severity = QUAIL_TEST_SEVERE;

        function check() {
                foreach($this->getAllElements('object') as $object) {
                        if(!$object->hasAttribute('title'))
                                $this->addReport($object);
                        
                }
        }

}




class objectMustHaveValidTitle extends quailTest {

        var $default_severity = QUAIL_TEST_SEVERE;

        var $strings = array('en' => array('nbsp', 
                                                                                        '&nbsp;', 
                                                                                        'object', 
                                                                                        'an object', 
                                                                                        'spacer', 
                                                                                        'image', 
                                                                                        'img', 
                                                                                        'photo', 
                                                                                        ' '),
                                                          'es' => array('nbsp', 
                                                                                        '&nbsp;', 
                                                                                        'objeto', 
                                                                                        'un objeto', 
                                                                                        'espacio', 
                                                                                        'imagen', 
                                                                                        'img', 
                                                                                        'foto', 
                                                                                        ' '),
                                                         );

        function check() {
                foreach($this->getAllElements('object') as $object) {
                        if($object->hasAttribute('title')) {
                                if(trim($object->getAttribute('title')) == '')
                                        $this->addReport($object);
                                elseif(!in_array(trim(strtolower($object->getAttribute('title'))), $this->translation()))
                                        $this->addReport($object);
                        }
                }
        }

}

class objectProvidesMechanismToReturnToParent extends quailTagTest {

        var $default_severity = QUAIL_TEST_SUGGESTION;
        
        var $tag = 'object';
}

class objectShouldHaveLongDescription extends quailTagTest {

        var $default_severity = QUAIL_TEST_SUGGESTION;

        var $tag = 'object';
}

class objectTextUpdatesWhenObjectChanges extends quailTagTest {

        var $default_severity = QUAIL_TEST_SUGGESTION;

        var $tag = 'object';
}

class objectUIMustBeAccessible extends quailTagTest {

        var $default_severity = QUAIL_TEST_SUGGESTION;

        var $tag = 'object';
}

class objectWithClassIDHasNoText extends quailTest {

        var $default_severity = QUAIL_TEST_SEVERE;

        function check() {
                foreach($this->getAllElements('object') as $object) {
                        if($object->nodeValue && $object->hasAttribute('classid'))
                                $this->addReport($object);
                
                }
        }
}

class pNotUsedAsHeader extends quailTest {

        var $default_severity = QUAIL_TEST_SEVERE;

        var $head_tags = array('strong', 'em', 'font', 'i', 'b', 'u');
        
        function check() {
                foreach($this->getAllElements('p') as $p) {
                        if(($p->nodeValue == $p->firstChild->nodeValue) &&
                                is_object($p->firstChild) &&
                                property_exists($p->firstChild, 'tagName') && 
                                in_array($p->firstChild->tagName, $this->head_tags)) {
                                        $this->addReport($p);
                                        
                        }
                        else {
                                $style = $this->css->getStyle($p);
                                if($style['font-weight'] == 'bold') {
                                        $this->addReport($p);
                                }
                        }
                }
        }
}

class passwordHasLabel extends inputHasLabel {

        var $default_severity = QUAIL_TEST_SEVERE;

        var $tag = 'input';
        
        var $type = 'password';
        
        var $no_type = false;
}

class passwordLabelIsNearby extends quailTest {

        var $default_severity = QUAIL_TEST_MODERATE;

        function check() {
                foreach($this->getAllElements('input') as $input) {
                        if($input->getAttribute('type') == 'password')
                                $this->addReport($input);
                        
                }
        }
}

class preShouldNotBeUsedForTabularLayout extends quailTest {

        var $default_severity = QUAIL_TEST_SUGGESTION;

        function check() {
                foreach($this->getAllElements('pre') as $pre) {
                        $rows = preg_split('/[\n\r]+/', $pre->nodeValue);
                        if(count($rows) > 1)
                                $this->addReport($pre);
                }
        
        }
}

class radioHasLabel extends inputHasLabel {

        var $default_severity = QUAIL_TEST_SEVERE;

        var $tag = 'input';
        
        var $type = 'radio';
        
        var $no_type = false;
}

class radioLabelIsNearby extends quailTest {

        function check() {
                foreach($this->getAllElements('input') as $input) {
                        if($input->getAttribute('type') == 'radio')
                                $this->addReport($input);
                        
                }
        }
}

class radioMarkedWithFieldgroupAndLegend extends quailTest {

        var $default_severity = QUAIL_TEST_SEVERE;

        function check() {
                $radios = array();
                foreach($this->getAllElements('input') as $input) {
                        if($input->getAttribute('type') == 'radio') {
                                $radios[$input->getAttribute('name')][] = $input;
                        }
                }
                foreach($radios as $radio) {
                        if(count($radio > 1)) {
                                if(!$this->getParent($radio[0], 'fieldset', 'body'))
                                        $this->addReport($radio[0]);
                        }
                }
        }
}

class scriptContentAccessibleWithScriptsTurnedOff extends quailTagTest {

        var $default_severity = QUAIL_TEST_SUGGESTION;

        var $tag = 'script';
}

class scriptInBodyMustHaveNoscript extends quailTest {

        var $default_severity = QUAIL_TEST_SEVERE;

        function check() {
                foreach($this->getAllElements('script') as $script) {
                        if(!$this->propertyIsEqual($script->nextSibling, 'tagName', 'noscript') 
                                && !$this->propertyIsEqual($script->parentNode, 'tagName', 'head'))
                                        $this->addReport($script);
                
                }
        }

}

class scriptOnclickRequiresOnKeypress extends quailTest {

        var $default_severity = QUAIL_TEST_SEVERE;
        
        var $click_value = 'onclick';

        var $key_value = 'onkeypress';
        
        function check() {
                foreach($this->getAllElements(array_keys(htmlElements::$html_elements)) as $element) {
                        if(($element->hasAttribute($this->click_value)) && !$element->hasAttribute($this->key_value))
                                $this->addReport($element);
                }
        }

}

class scriptOndblclickRequiresOnKeypress extends scriptOnclickRequiresOnKeypress {

        var $click_value = 'ondblclick';
}

class scriptOnmousedownRequiresOnKeypress extends scriptOnclickRequiresOnKeypress {

        var $click_value = 'onmousedown';
        
        var $key_value = 'onkeydown';
}

class scriptOnmousemove extends quailTest {

        var $default_severity = QUAIL_TEST_SEVERE;

        var $click_value = 'onmousemove';
        
        var $key_value = 'onkeypress';
        
        function check() {
                foreach($this->getAllElements(array_keys(htmlElements::$html_elements)) as $element) {
                        if(($element->hasAttribute($this->click_value)))
                                $this->addReport($element);
                }
        }

}

class scriptOnmouseoutHasOnmouseblur extends scriptOnclickRequiresOnKeypress {

        var $click_value = 'onmouseout';
        
        var $key_value = 'onblur';
}

class scriptOnmouseoverHasOnfocus extends scriptOnclickRequiresOnKeypress {

        var $click_value = 'onmouseover';
        
        var $key_value = 'onfocus';
}

class scriptOnmouseupHasOnkeyup extends scriptOnclickRequiresOnKeypress {

        var $click_value = 'onmouseup';
        
        var $key_value = 'onkeyup';
}

class scriptUIMustBeAccessible extends quailTagTest {

        var $default_severity = QUAIL_TEST_SUGGESTION;

        var $tag = 'script';
}

class scriptsDoNotFlicker extends quailTagTest {

        var $default_severity = QUAIL_TEST_SUGGESTION;

        var $tag = 'script';
}

class scriptsDoNotUseColorAlone extends quailTagTest {

        var $default_severity = QUAIL_TEST_SUGGESTION;

        var $tag = 'script';
}

class selectDoesNotChangeContext extends quailTest {

        var $default_severity = QUAIL_TEST_SEVERE;

        function check() {
                foreach($this->getAllElements('select') as $select) {
                        if($select->hasAttribute('onchange'))
                                $this->addReport($select);
                
                }
        }
}

class selectHasAssociatedLabel extends inputHasLabel {

        var $default_severity = QUAIL_TEST_SEVERE;

        var $tag = 'select';

        var $no_type = true;
}

class selectWithOptionsHasOptgroup extends quailTest {

        var $default_severity = QUAIL_TEST_MODERATE;

        function check() {
                foreach($this->getAllElements('select') as $select) {
                        $options = 0;
                        foreach($select->childNodes as $child) {
                                if($this->propertyIsEqual($child, 'tagName', 'option')) {
                                        $options++;
                                }
                        }
                        if($options >= 4) {
                                $this->addReport($select);
                        }
                }
        }
}

class siteMap extends quailTest {

        var $default_severity = QUAIL_TEST_SUGGESTION;
        
        var $cms = false;
        
        function check() {
                foreach($this->getAllElements('a') as $a) {
                        if(strtolower(trim($a->nodeValue)) == 'site map')
                                return true;
                }
                $this->addReport(null, null, false);
        }
}

class skipToContentLinkProvided extends quailTest {
        
        var $cms = false;
        
        var $default_severity = QUAIL_TEST_MODERATE;
        
        var $strings = array('en' => array('navigation', 'skip', 'content'),
                                                 'es' => array('navegaci&oacute;n', 'saltar', 'contenido'),
                                                );
        
        function check() {
                $first_link = $this->getAllElements('a');
                if(!$first_link) {
                        $this->addReport(null, null, false);
                        return null;
                }
                $a = $first_link[0];
                
                if(substr($a->getAttribute('href'), 0, 1) == '#') {
                        
                        $link_text = explode(' ', strtolower($a->nodeValue));
                        if(!in_array($this->translation(), $link_text)) {
                                $report = true;
                                foreach($a->childNodes as $child) {
                                        if(method_exists($child, 'hasAttribute')) {
                                                if($child->hasAttribute('alt')) {
                                                        $alt = explode(' ', strtolower($child->getAttribute('alt') . $child->nodeValue));
                                                        foreach($this->translation() as $word) {
                                                                if(in_array($word, $alt)) {
                                                                        $report = false;
                                                                }
                                                        }
                                                }
                                        }
                                }
                                if($report) {
                                        $this->addReport(null, null, false);
                                }
                        }
                
                }
                else
                        $this->addReport(null, null, false);

        }

} 


class tabIndexFollowsLogicalOrder extends quailTest {

        var $default_severity = QUAIL_TEST_MODERATE;
        
        function check() {
                $index = 0;
                foreach($this->getAllElements(null, 'form') as $form) {
                        if(is_numeric($form->getAttribute('tabindex'))
                                && intval($form->getAttribute('tabindex')) != $index + 1)
                                        $this->addReport($form);
                        $index++;
                }
        }
}

class tableCaptionIdentifiesTable extends quailTagTest {

        var $default_severity = QUAIL_TEST_SUGGESTION;

        var $tag = 'caption';
}

class tableComplexHasSummary extends quailTableTest {

        var $default_severity = QUAIL_TEST_SEVERE;

        function check() {
                foreach($this->getAllElements('table') as $table) {
                        if(!$table->hasAttribute('summary') && $table->firstChild->tagName != 'caption') {
                                $this->addReport($table);
                        
                        
                        }
                }
        
        }
}

class tableDataShouldHaveTh extends quailTableTest {

        var $default_severity = QUAIL_TEST_SEVERE;

        function check() {
                foreach($this->getAllElements('table') as $table) {
                        if(!$this->isData($table))
                                $this->addReport($table);
                
                }
        
        }

}

class tableHeaderLabelMustBeTerse extends quailTableTest {

        var $default_severity = QUAIL_TEST_MODERATE;

        function check() {
                foreach($this->getAllElements('table') as $table) {
                        foreach($table->childNodes as $child) {
                                if($this->propertyIsEqual($child, 'tagName', 'tr')) {
                                        foreach($child->childNodes as $td) {
                                                if($this->propertyIsEqual($td, 'tagName', 'th')) {
                                                        if(strlen($td->getAttribute('abbr')) > 20)
                                                                $this->addReport($td);
                                                
                                                }
                                        }
                                }
                        }
                        
                }
        
        }
}

class tableIsGrouped extends quailTest {

        var $default_severity = QUAIL_TEST_MODERATE;

        function check() {
                foreach($this->getAllElements('table') as $table) {
                        if(!$this->elementHasChild($table, 'thead') 
                                        || !$this->elementHasChild($table, 'tbody') 
                                        || !$this->elementHasChild($table, 'tfoot')) {
                                $rows = 0;
                                foreach($table->childNodes as $child) {
                                        if($this->propertyIsEqual($child, 'tagName', 'tr'))
                                                $rows ++;
                                }
                                if($rows > 4)
                                        $this->addReport($table);
                        }               
                }
        
        }
}

class tableLayoutDataShouldNotHaveTh extends quailTableTest {

        var $default_severity = QUAIL_TEST_SUGGESTION;

        function check() {
                foreach($this->getAllElements('table') as $table) {
                        if($this->isData($table))
                                $this->addReport($table);
                
                }
        
        }

}

class tableLayoutHasNoCaption extends quailTableTest {

        var $default_severity = QUAIL_TEST_SEVERE;

        function check() {
                foreach($this->getAllElements('table') as $table) {
                        if($this->elementHasChild($table, 'caption')) {
                                $first_row = true;
                                foreach($table->childNodes as $child) {
                                        if($this->propertyIsEqual($child, 'tagName', 'tr') && $first_row) {
                                                if(!$this->elementHasChild($child, 'th'))
                                                        $this->addReport($table);
                                                $first_row = false;
                                        }
                                }
                        }
                }
        
        }
}

class tableLayoutHasNoSummary extends quailTableTest {

        var $default_severity = QUAIL_TEST_SEVERE;

        function check() {
                foreach($this->getAllElements('table') as $table) {
                        if($table->hasAttribute('summary') && strlen(trim($table->getAttribute('summary'))) > 1) {
                                $first_row = true;
                                foreach($table->childNodes as $child) {
                                        if($this->propertyIsEqual($child, 'tagName', 'tr') && $first_row) {
                                                if(!$this->elementHasChild($child, 'th'))
                                                        $this->addReport($table);
                                                $first_row = false;
                                        }
                                }
                        }
                }
        
        }
}

class tableLayoutMakesSenseLinearized extends quailTableTest {

        var $default_severity = QUAIL_TEST_SUGGESTION;

        function check() {
                foreach($this->getAllElements('table') as $table) {
                        if(!$this->isData($table))
                                $this->addReport($table);
                
                }
        
        }

}

class tableSummaryDescribesTable extends quailTest {

        var $default_severity = QUAIL_TEST_SUGGESTION;

        function check() {
                foreach($this->getAllElements('table') as $table) {
                        if($table->hasAttribute('summary'))
                                $this->addReport($table);
                }
        }
}

class tableSummaryDoesNotDuplicateCaption extends quailTest {

        var $default_severity = QUAIL_TEST_SEVERE;

        function check() {
                foreach($this->getAllElements('table') as $table) {
                        if($this->elementHasChild($table, 'caption') && $table->hasAttribute('summary')) {
                                foreach($table->childNodes as $child) {
                                        if($this->propertyIsEqual($child, 'tagName', 'caption'))
                                                $caption = $child;
                                }
                                if(strtolower(trim($caption->nodeValue)) == 
                                                strtolower(trim($table->getAttribute('summary'))) ) 
                                 $this->addReport($table);
                                
                        }
                }
        }
}

class tableSummaryIsEmpty extends quailTableTest {

        var $default_severity = QUAIL_TEST_SEVERE;

        function check() {
                foreach($this->getAllElements('table') as $table) {
                        if($table->hasAttribute('summary') && trim($table->getAttribute('summary')) == '') {
                                $this->addReport($table);
                        
                        
                        }
                }
        
        }
}

class tableSummaryIsSufficient extends quailTableTest {

        var $default_severity = QUAIL_TEST_SUGGESTION;

        function check() {
                foreach($this->getAllElements('table') as $table) {
                        if($table->hasAttribute('summary') && strlen(trim($table->getAttribute('summary'))) < 11) {
                                $this->addReport($table);
                        
                        
                        }
                }
        
        }
}

class tableUseColGroup extends quailTableTest {

        var $default_severity = QUAIL_TEST_SUGGESTION;

        function check() {
                foreach($this->getAllElements('table') as $table) {
                        if($this->isData($table)) {
                                if(!$this->elementHasChild($table, 'colgroup') && !$this->elementHasChild($table, 'col'))
                                        $this->addReport($table);
                        }
                }
        
        }
}

class tableUsesAbbreviationForHeader extends quailTableTest {

        var $default_severity = QUAIL_TEST_SUGGESTION;

        function check() {
                foreach($this->getAllElements('table') as $table) {
                        foreach($table->childNodes as $child) {
                                if($this->propertyIsEqual($child, 'tagName', 'tr')) {
                                        foreach($child->childNodes as $td) {
                                                if($this->propertyIsEqual($td, 'tagName', 'th')) {
                                                        if(strlen($td->nodeValue) > 20 && !$td->hasAttribute('abbr'))
                                                                $this->addReport($table);
                                                
                                                }
                                        }
                                }
                        }
                        
                }
        
        }
}

class tableUsesCaption extends quailTableTest {

        var $default_severity = QUAIL_TEST_SEVERE;

        function check() {
                foreach($this->getAllElements('table') as $table) {
                        if($table->firstChild->tagName != 'caption')
                                $this->addReport($table);
                        
                }
        
        }
}

class tableWithBothHeadersUseScope extends quailTest {

        var $default_severity = QUAIL_TEST_MODERATE;

        function check() {
                foreach($this->getAllElements('table') as $table) {
                        $fail = false;
                        foreach($table->childNodes as $child) {
                                if($this->propertyIsEqual($child, 'tagName', 'tr')) {
                                        if($this->propertyIsEqual($child->firstChild, 'tagName', 'td')) {
                                                if(!$child->firstChild->hasAttribute('scope'))
                                                        $fail = true;
                                        }
                                        else {
                                                foreach($child->childNodes as $td) {
                                                        if($td->tagName == 'th' && !$td->hasAttribute('scope'))
                                                                $fail = true;
                                                }
                                        }
                                }
                        }
                        if($fail)
                                $this->addReport($table);
                }
        }
}

class tableWithMoreHeadersUseID extends quailTableTest {
        
        var $default_severity = QUAIL_TEST_MODERATE;

        function check() {
                foreach($this->getAllElements('table') as $table) {
                        if($this->isData($table)) {
                                
                                $row = 0;
                                $multi_headers = false;
                                foreach($table->childNodes as $child) {
                                        if($this->propertyIsEqual($child, 'tagName', 'tr')) {
                                                $row ++;
                                                foreach($child->childNodes as $cell) {
                                                        if($this->propertyIsEqual($cell, 'tagName', 'th')) {
                                                                $th[] = $cell;
                                                                if($row > 1) 
                                                                        $multi_headers = true;  
                                                        }
                                                                
                                                }
                                        }
                                }
                                if($multi_headers) {
                                        $fail = false;
                                        foreach($th as $cell) {
                                                if(!$cell->hasAttribute('id'))
                                                        $fail = true;
                                        }
                                        if($fail)
                                                $this->addReport($table);
                                } 
                                
                        }
                }
        }
}

class tabularDataIsInTable extends quailTest {

        var $default_severity = QUAIL_TEST_MODERATE;

        function check() {
                foreach($this->getAllElements(null, 'text') as $text) {
                        if(strpos($text->nodeValue, "\t") !== false || $text->tagName == 'pre')
                                $this->addReport($text);
                }
        }
}

class textareaHasAssociatedLabel extends inputHasLabel {

        var $default_severity = QUAIL_TEST_SEVERE;

        var $tag = 'textarea';
        
        var $no_type = true;
}

class textareaLabelPositionedClose extends quailTagTest {

        var $default_severity = QUAIL_TEST_MODERATE;

        var $tag = 'textarea';
}

class svgContainsTitle extends quailTest {
        
        var $default_severity = QUAIL_TEST_SEVERE;
        
        function check() {
                foreach($this->getAllElements('svg') as $svg) {
                        $title = false;
                        foreach($svg->childNodes as $child) {
                                if($this->propertyIsEqual($child, 'tagName', 'title')) {
                                        $title = true;
                                }
                        }
                        if(!$title) {
                                $this->addReport($svg);
                        }
                }
        }
}

class videoProvidesCaptions extends quailTagTest {
        
        var $default_severity = QUAIL_TEST_SUGGESTION;
        
        var $tag = 'video';
}

class videosEmbeddedOrLinkedNeedCaptions extends quailTest {
        
        var $default_severity = QUAIL_TEST_SEVERE;

        var $services = array(
                                        'youtube' => 'media/youtube',
        );
        
        function check() {
                foreach($this->getAllElements(array('a', 'embed')) as $video) {
                        $attr = ($video->tagName == 'a')
                                         ? 'href'
                                         : 'src';

                        if($video->hasAttribute($attr)) {
                                foreach($this->services as $service) {
                                        if($service->captionsMissing($video->getAttribute($attr))) {
                                                $this->addReport($video);
                                        }
                                }
                        }
                }
        }
        
}

class documentIsWrittenClearly extends quailTest {
        
        var $default_severity = QUAIL_TEST_MODERATE;
        
        var $services = array(
                'readability' => 'readability/readability',
        );
        
        function check() {
                $readability = $this->services['readability'];
                foreach($this->getAllElements(null, 'text') as $element) {
                        $text = strip_tags($element->nodeValue);
                        if(str_word_count($text) > 25) {
                                if($readability->flesch_kincaid_reading_ease($text) < 60) {
                                        $this->addReport($element);
                                }
                        }
                }
        }
        
}

class headersHaveText extends quailTest {
        
        var $default_severity = QUAIL_TEST_SEVERE;
        
        function check() {
                foreach($this->getAllElements(null, 'header', true) as $header) {
                        if(!$this->elementContainsReadableText($header)) {
                                $this->addReport($header);
                        }
                }
        }
}

class labelsAreAssignedToAnInput extends quailTest {
        
        var $default_severity = QUAIL_TEST_SEVERE;
        
        function check() {
                foreach($this->getAllElements('label') as $label) {
                        if(!$label->hasAttribute('for') || !$input = $this->dom->getElementById($label->getAttribute('for'))) {
                                $this->addReport($label);
                        }
                        if(!in_array($input->tagName, array('input', 'select', 'textarea'))) {
                                $this->addReport($label);
                        }
                }
        }
}

class imgAltTextNotRedundant extends quailTest {
        
        var $default_severity = QUAIL_TEST_SEVERE;
        
        function check() {
                $alt = array();
                foreach($this->getAllElements('img') as $img) { 
                        if($img->hasAttribute('src') && $img->hasAttribute('alt')) {
                                if(isset($alt[strtolower(trim($img->getAttribute('alt')))]) &&
                                        $alt[strtolower(trim($img->getAttribute('alt')))] != 
                                        strtolower(trim($img->getAttribute('src')))) {
                                                $this->addReport($img);
                                }
                                $alt[strtolower(trim($img->getAttribute('alt')))] = strtolower(trim($img->getAttribute('src')));
                        }
                }
                unset($alt);
        }
}

class selectJumpMenus extends quailTest {
        
        var $default_severity = QUAIL_TEST_MODERATE;
        
        function check() {
                foreach($this->getAllElements('select') as $select) {
                        $parent = $this->getParent($select, 'form', 'body');
                        $fail = true;
                        if($parent) {
                                foreach($this->getAllElements('input') as $input) {
                                        if($input->hasAttribute('type') && $input->getAttribute('type') == 'submit') {
                                                $parent_input = $this->getParent($input, 'form', 'body');
                                                if($parent_input->isSameNode($parent)) {
                                                        $fail = false;
                                                }
                                        }
                                }
                        }
                        if($fail) {
                                $this->addReport($select);
                        }
                }
        }
}


class textIsNotSmall extends quailTest {
        
        var $default_severity = QUAIL_TEST_MODERATE;
        
        function check() {
                foreach($this->getAllElements(null, 'text', true) as $text) {
                        $style = $this->css->getStyle($text);
                        if(isset($style['font-size'])) {
                                if(substr($style['font-size'], -2, 2) == 'px') {
                                        if(intval($style['font-size']) < 10) {
                                                $this->addReport($text);
                                        }
                                }
                                if(substr($style['font-size'], -2, 2) == 'em') {
                                        if(floatval($style['font-size']) < .63) {
                                                $this->addReport($text);
                                        }
                                }
                        }
                }
        }

}

---