Mobile Responsiveness Testing - Complete Guide

# Responsive Design Testing

# 1. CSS Media Queries
/* Mobile First Approach */
.container {
  width: 100%;
  padding: 16px;
  font-size: 14px;
}

/* Small devices (landscape phones, 576px and up) */
@media (min-width: 576px) {
  .container {
    padding: 20px;
    font-size: 16px;
  }
}

/* Medium devices (tablets, 768px and up) */
@media (min-width: 768px) {
  .container {
    padding: 24px;
    font-size: 18px;
  }
  
  .grid {
    display: grid;
    grid-template-columns: repeat(2, 1fr);
    gap: 20px;
  }
}

/* Large devices (desktops, 992px and up) */
@media (min-width: 992px) {
  .container {
    max-width: 1200px;
    margin: 0 auto;
    padding: 32px;
  }
  
  .grid {
    grid-template-columns: repeat(3, 1fr);
    gap: 24px;
  }
}

/* Extra large devices (large desktops, 1200px and up) */
@media (min-width: 1200px) {
  .container {
    padding: 40px;
  }
  
  .grid {
    grid-template-columns: repeat(4, 1fr);
    gap: 32px;
  }
}

# 2. Flexible Grid System
.row {
  display: flex;
  flex-wrap: wrap;
  margin: 0 -15px;
}

.col {
  flex: 1;
  padding: 0 15px;
  margin-bottom: 20px;
}

.col-sm-6 {
  flex: 0 0 50%;
}

.col-md-4 {
  flex: 0 0 33.333333%;
}

.col-lg-3 {
  flex: 0 0 25%;
}

@media (max-width: 767px) {
  .col-sm-6,
  .col-md-4,
  .col-lg-3 {
    flex: 0 0 100%;
  }
}

# 3. Responsive Images
.responsive-image {
  max-width: 100%;
  height: auto;
  display: block;
}

/* Picture element for different screen sizes */

  
  
  


/* CSS for different image sizes */
.hero-image {
  background-image: url('hero-small.jpg');
  background-size: cover;
  background-position: center;
  height: 200px;
}

@media (min-width: 768px) {
  .hero-image {
    background-image: url('hero-medium.jpg');
    height: 300px;
  }
}

@media (min-width: 1200px) {
  .hero-image {
    background-image: url('hero-large.jpg');
    height: 400px;
  }
}

# 4. Responsive Typography
/* Fluid typography */
:root {
  --font-size-base: clamp(14px, 2.5vw, 18px);
  --font-size-h1: clamp(24px, 5vw, 48px);
  --font-size-h2: clamp(20px, 4vw, 36px);
  --font-size-h3: clamp(18px, 3vw, 24px);
}

body {
  font-size: var(--font-size-base);
  line-height: 1.6;
}

h1 {
  font-size: var(--font-size-h1);
  margin-bottom: 1rem;
}

h2 {
  font-size: var(--font-size-h2);
  margin-bottom: 0.8rem;
}

h3 {
  font-size: var(--font-size-h3);
  margin-bottom: 0.6rem;
}

/* Responsive line height */
@media (max-width: 767px) {
  body {
    line-height: 1.5;
  }
}

# 5. Touch-Friendly Design
/* Touch targets */
.button {
  min-height: 44px;
  min-width: 44px;
  padding: 12px 24px;
  font-size: 16px;
  border: none;
  border-radius: 8px;
  cursor: pointer;
  touch-action: manipulation;
}

/* Hover states for touch devices */
@media (hover: hover) {
  .button:hover {
    background-color: #0056b3;
    transform: translateY(-2px);
  }
}

/* Focus states for accessibility */
.button:focus {
  outline: 2px solid #007bff;
  outline-offset: 2px;
}

/* Active states for touch */
.button:active {
  transform: translateY(0);
  background-color: #004085;
}

# 6. Mobile Navigation
/* Mobile menu */
.mobile-menu-toggle {
  display: none;
  background: none;
  border: none;
  font-size: 24px;
  cursor: pointer;
  padding: 8px;
}

@media (max-width: 767px) {
  .mobile-menu-toggle {
    display: block;
  }
  
  .nav-menu {
    position: fixed;
    top: 0;
    left: -100%;
    width: 100%;
    height: 100vh;
    background: white;
    flex-direction: column;
    justify-content: center;
    align-items: center;
    transition: left 0.3s ease;
    z-index: 1000;
  }
  
  .nav-menu.active {
    left: 0;
  }
  
  .nav-menu li {
    margin: 20px 0;
  }
  
  .nav-menu a {
    font-size: 24px;
    color: #333;
  }
}

# 7. Responsive Forms
.form-group {
  margin-bottom: 20px;
}

.form-control {
  width: 100%;
  padding: 12px 16px;
  font-size: 16px;
  border: 1px solid #ddd;
  border-radius: 4px;
  box-sizing: border-box;
}

/* Prevent zoom on iOS */
@media screen and (-webkit-min-device-pixel-ratio: 0) {
  select,
  textarea,
  input[type="text"],
  input[type="password"],
  input[type="datetime"],
  input[type="datetime-local"],
  input[type="date"],
  input[type="month"],
  input[type="time"],
  input[type="week"],
  input[type="number"],
  input[type="email"],
  input[type="url"],
  input[type="search"],
  input[type="tel"],
  input[type="color"] {
    font-size: 16px;
  }
}

/* Responsive form layout */
@media (min-width: 768px) {
  .form-row {
    display: flex;
    gap: 20px;
  }
  
  .form-row .form-group {
    flex: 1;
  }
}

# 8. Performance Optimization
/* Lazy loading for images */
.lazy-image {
  opacity: 0;
  transition: opacity 0.3s;
}

.lazy-image.loaded {
  opacity: 1;
}

/* Critical CSS for above-the-fold content */
.critical-content {
  /* Inline critical CSS */
}

/* Non-critical CSS loading */



# 9. Viewport Configuration
/* HTML viewport meta tag */


/* CSS for different orientations */
@media (orientation: portrait) {
  .landscape-only {
    display: none;
  }
}

@media (orientation: landscape) {
  .portrait-only {
    display: none;
  }
}

# 10. Testing Utilities
/* Debug responsive design */
.debug-responsive {
  position: fixed;
  top: 0;
  right: 0;
  background: rgba(0, 0, 0, 0.8);
  color: white;
  padding: 10px;
  font-size: 12px;
  z-index: 9999;
}

.debug-responsive::before {
  content: "Mobile";
}

@media (min-width: 576px) {
  .debug-responsive::before {
    content: "Small";
  }
}

@media (min-width: 768px) {
  .debug-responsive::before {
    content: "Medium";
  }
}

@media (min-width: 992px) {
  .debug-responsive::before {
    content: "Large";
  }
}

@media (min-width: 1200px) {
  .debug-responsive::before {
    content: "Extra Large";
  }
}

# Mobile Testing Tools and Techniques

# 1. Browser DevTools Testing
// JavaScript for responsive testing
class ResponsiveTester {
  constructor() {
    this.devices = {
      mobile: { width: 375, height: 667, name: 'iPhone SE' },
      tablet: { width: 768, height: 1024, name: 'iPad' },
      desktop: { width: 1920, height: 1080, name: 'Desktop' }
    };
    
    this.currentDevice = 'desktop';
    this.isTesting = false;
  }
  
  startTesting() {
    this.isTesting = true;
    this.createTestingUI();
    this.addEventListeners();
  }
  
  createTestingUI() {
    const tester = document.createElement('div');
    tester.id = 'responsive-tester';
    tester.innerHTML = `
      

        
Responsive Testing
        

          ${Object.entries(this.devices).map(([key, device]) => `
            
              ${device.name}
            
          `).join('')}
        
        

          
          
          Apply
        
        

          1920 x 1080
        
      
    `;
    
    document.body.appendChild(tester);
  }
  
  addEventListeners() {
    document.querySelectorAll('.device-btn').forEach(btn => {
      btn.addEventListener('click', (e) => {
        const device = e.target.dataset.device;
        this.switchDevice(device);
      });
    });
    
    document.getElementById('apply-custom').addEventListener('click', () => {
      const width = document.getElementById('custom-width').value;
      const height = document.getElementById('custom-height').value;
      this.setCustomSize(width, height);
    });
  }
  
  switchDevice(deviceKey) {
    const device = this.devices[deviceKey];
    this.currentDevice = deviceKey;
    
    // Update active button
    document.querySelectorAll('.device-btn').forEach(btn => {
      btn.classList.remove('active');
    });
    document.querySelector(`[data-device="${deviceKey}"]`).classList.add('active');
    
    // Resize window
    this.resizeWindow(device.width, device.height);
  }
  
  setCustomSize(width, height) {
    this.resizeWindow(width, height);
    document.getElementById('current-size').textContent = `${width} x ${height}`;
  }
  
  resizeWindow(width, height) {
    // This would work in a testing environment
    console.log(`Resizing to ${width}x${height}`);
    document.getElementById('current-size').textContent = `${width} x ${height}`;
  }
}

// CSS for testing UI
const testerCSS = `
#responsive-tester {
  position: fixed;
  top: 20px;
  right: 20px;
  background: white;
  border: 1px solid #ddd;
  border-radius: 8px;
  box-shadow: 0 4px 12px rgba(0,0,0,0.15);
  z-index: 10000;
  font-family: Arial, sans-serif;
}

.tester-panel {
  padding: 20px;
  min-width: 250px;
}

.tester-panel h3 {
  margin: 0 0 15px 0;
  font-size: 16px;
  color: #333;
}

.device-buttons {
  display: flex;
  gap: 8px;
  margin-bottom: 15px;
}

.device-btn {
  padding: 8px 12px;
  border: 1px solid #ddd;
  background: white;
  border-radius: 4px;
  cursor: pointer;
  font-size: 12px;
}

.device-btn.active {
  background: #007bff;
  color: white;
  border-color: #007bff;
}

.custom-size {
  display: flex;
  gap: 8px;
  margin-bottom: 15px;
}

.custom-size input {
  width: 60px;
  padding: 4px 8px;
  border: 1px solid #ddd;
  border-radius: 4px;
  font-size: 12px;
}

.custom-size button {
  padding: 4px 8px;
  background: #28a745;
  color: white;
  border: none;
  border-radius: 4px;
  cursor: pointer;
  font-size: 12px;
}

.tester-info {
  font-size: 12px;
  color: #666;
  text-align: center;
}
`;

// Inject CSS
const style = document.createElement('style');
style.textContent = testerCSS;
document.head.appendChild(style);

# 2. Automated Testing Script
class MobileTestAutomation {
  constructor() {
    this.testResults = [];
    this.breakpoints = [320, 375, 414, 768, 1024, 1200, 1920];
  }
  
  async runTests() {
    console.log('Starting mobile responsiveness tests...');
    
    for (const width of this.breakpoints) {
      await this.testBreakpoint(width);
    }
    
    this.generateReport();
  }
  
  async testBreakpoint(width) {
    console.log(`Testing breakpoint: ${width}px`);
    
    // Simulate viewport change
    this.setViewport(width);
    
    // Wait for layout to settle
    await this.wait(1000);
    
    // Run tests
    const results = {
      width,
      timestamp: Date.now(),
      tests: {
        layout: this.testLayout(),
        typography: this.testTypography(),
        images: this.testImages(),
        navigation: this.testNavigation(),
        forms: this.testForms()
      }
    };
    
    this.testResults.push(results);
  }
  
  setViewport(width) {
    // In a real testing environment, this would change the viewport
    document.documentElement.style.setProperty('--test-width', `${width}px`);
  }
  
  testLayout() {
    const issues = [];
    
    // Check for horizontal scroll
    if (document.documentElement.scrollWidth > window.innerWidth) {
      issues.push('Horizontal scroll detected');
    }
    
    // Check for overflow
    const overflowingElements = document.querySelectorAll('*');
    overflowingElements.forEach(el => {
      if (el.scrollWidth > el.clientWidth) {
        issues.push(`Element ${el.tagName} is overflowing`);
      }
    });
    
    return {
      passed: issues.length === 0,
      issues
    };
  }
  
  testTypography() {
    const issues = [];
    
    // Check font sizes
    const textElements = document.querySelectorAll('p, h1, h2, h3, h4, h5, h6');
    textElements.forEach(el => {
      const fontSize = parseFloat(getComputedStyle(el).fontSize);
      if (fontSize < 12) {
        issues.push(`Text too small: ${el.tagName} (${fontSize}px)`);
      }
    });
    
    return {
      passed: issues.length === 0,
      issues
    };
  }
  
  testImages() {
    const issues = [];
    
    // Check image responsiveness
    const images = document.querySelectorAll('img');
    images.forEach(img => {
      if (img.naturalWidth > img.clientWidth * 2) {
        issues.push(`Image ${img.src} is too large for container`);
      }
      
      if (!img.alt) {
        issues.push(`Image ${img.src} missing alt text`);
      }
    });
    
    return {
      passed: issues.length === 0,
      issues
    };
  }
  
  testNavigation() {
    const issues = [];
    
    // Check mobile menu
    const mobileMenu = document.querySelector('.mobile-menu-toggle');
    if (window.innerWidth < 768 && !mobileMenu) {
      issues.push('Mobile menu not found for small screens');
    }
    
    // Check touch targets
    const buttons = document.querySelectorAll('button, a');
    buttons.forEach(btn => {
      const rect = btn.getBoundingClientRect();
      if (rect.width < 44 || rect.height < 44) {
        issues.push(`Touch target too small: ${btn.textContent}`);
      }
    });
    
    return {
      passed: issues.length === 0,
      issues
    };
  }
  
  testForms() {
    const issues = [];
    
    // Check form inputs
    const inputs = document.querySelectorAll('input, textarea, select');
    inputs.forEach(input => {
      const fontSize = parseFloat(getComputedStyle(input).fontSize);
      if (fontSize < 16) {
        issues.push(`Form input font size too small: ${fontSize}px`);
      }
    });
    
    return {
      passed: issues.length === 0,
      issues
    };
  }
  
  wait(ms) {
    return new Promise(resolve => setTimeout(resolve, ms));
  }
  
  generateReport() {
    console.log('Mobile Responsiveness Test Report');
    console.log('================================');
    
    this.testResults.forEach(result => {
      console.log(`\nBreakpoint: ${result.width}px`);
      
      Object.entries(result.tests).forEach(([testName, testResult]) => {
        const status = testResult.passed ? '✓' : '✗';
        console.log(`  ${status} ${testName}`);
        
        if (!testResult.passed) {
          testResult.issues.forEach(issue => {
            console.log(`    - ${issue}`);
          });
        }
      });
    });
  }
}

# 3. Performance Testing
class MobilePerformanceTester {
  constructor() {
    this.metrics = {};
  }
  
  async testPerformance() {
    console.log('Testing mobile performance...');
    
    // Test Core Web Vitals
    await this.testLCP();
    await this.testFID();
    await this.testCLS();
    
    // Test resource loading
    this.testResourceLoading();
    
    // Test memory usage
    this.testMemoryUsage();
    
    this.generatePerformanceReport();
  }
  
  async testLCP() {
    const observer = new PerformanceObserver((list) => {
      const entries = list.getEntries();
      const lastEntry = entries[entries.length - 1];
      this.metrics.lcp = lastEntry.startTime;
    });
    
    observer.observe({ entryTypes: ['largest-contentful-paint'] });
  }
  
  async testFID() {
    const observer = new PerformanceObserver((list) => {
      const entries = list.getEntries();
      entries.forEach(entry => {
        this.metrics.fid = entry.processingStart - entry.startTime;
      });
    });
    
    observer.observe({ entryTypes: ['first-input'] });
  }
  
  async testCLS() {
    let clsValue = 0;
    const observer = new PerformanceObserver((list) => {
      const entries = list.getEntries();
      entries.forEach(entry => {
        if (!entry.hadRecentInput) {
          clsValue += entry.value;
        }
      });
      this.metrics.cls = clsValue;
    });
    
    observer.observe({ entryTypes: ['layout-shift'] });
  }
  
  testResourceLoading() {
    const resources = performance.getEntriesByType('resource');
    this.metrics.resources = {
      total: resources.length,
      totalSize: resources.reduce((sum, resource) => sum + resource.transferSize, 0),
      loadTime: resources.reduce((sum, resource) => sum + resource.duration, 0)
    };
  }
  
  testMemoryUsage() {
    if (performance.memory) {
      this.metrics.memory = {
        used: performance.memory.usedJSHeapSize,
        total: performance.memory.totalJSHeapSize,
        limit: performance.memory.jsHeapSizeLimit
      };
    }
  }
  
  generatePerformanceReport() {
    console.log('Mobile Performance Report');
    console.log('========================');
    
    console.log(`LCP: ${this.metrics.lcp?.toFixed(2)}ms`);
    console.log(`FID: ${this.metrics.fid?.toFixed(2)}ms`);
    console.log(`CLS: ${this.metrics.cls?.toFixed(4)}`);
    
    if (this.metrics.resources) {
      console.log(`Resources: ${this.metrics.resources.total}`);
      console.log(`Total Size: ${(this.metrics.resources.totalSize / 1024).toFixed(2)}KB`);
      console.log(`Load Time: ${this.metrics.resources.loadTime.toFixed(2)}ms`);
    }
    
    if (this.metrics.memory) {
      console.log(`Memory Used: ${(this.metrics.memory.used / 1024 / 1024).toFixed(2)}MB`);
      console.log(`Memory Total: ${(this.metrics.memory.total / 1024 / 1024).toFixed(2)}MB`);
    }
  }
}

# 4. Accessibility Testing
class MobileAccessibilityTester {
  constructor() {
    this.issues = [];
  }
  
  testAccessibility() {
    console.log('Testing mobile accessibility...');
    
    this.testTouchTargets();
    this.testColorContrast();
    this.testTextSize();
    this.testFocusManagement();
    this.testScreenReader();
    
    this.generateAccessibilityReport();
  }
  
  testTouchTargets() {
    const interactiveElements = document.querySelectorAll('button, a, input, select, textarea');
    
    interactiveElements.forEach(element => {
      const rect = element.getBoundingClientRect();
      const minSize = 44; // iOS and Android minimum touch target size
      
      if (rect.width < minSize || rect.height < minSize) {
        this.issues.push({
          type: 'touch-target',
          element: element,
          message: `Touch target too small: ${rect.width}x${rect.height}px (minimum: ${minSize}x${minSize}px)`
        });
      }
    });
  }
  
  testColorContrast() {
    const textElements = document.querySelectorAll('p, h1, h2, h3, h4, h5, h6, span, a');
    
    textElements.forEach(element => {
      const styles = getComputedStyle(element);
      const color = styles.color;
      const backgroundColor = styles.backgroundColor;
      
      // This is a simplified check - in practice, you'd use a proper contrast ratio calculation
      if (color === backgroundColor) {
        this.issues.push({
          type: 'color-contrast',
          element: element,
          message: 'Text and background colors are the same'
        });
      }
    });
  }
  
  testTextSize() {
    const textElements = document.querySelectorAll('p, h1, h2, h3, h4, h5, h6, span, a');
    
    textElements.forEach(element => {
      const fontSize = parseFloat(getComputedStyle(element).fontSize);
      const minSize = 12; // Minimum readable font size
      
      if (fontSize < minSize) {
        this.issues.push({
          type: 'text-size',
          element: element,
          message: `Text too small: ${fontSize}px (minimum: ${minSize}px)`
        });
      }
    });
  }
  
  testFocusManagement() {
    const focusableElements = document.querySelectorAll('button, a, input, select, textarea, [tabindex]');
    
    focusableElements.forEach(element => {
      const styles = getComputedStyle(element);
      const outline = styles.outline;
      
      if (outline === 'none' || outline === '') {
        this.issues.push({
          type: 'focus-management',
          element: element,
          message: 'Element has no visible focus indicator'
        });
      }
    });
  }
  
  testScreenReader() {
    const images = document.querySelectorAll('img');
    
    images.forEach(img => {
      if (!img.alt && !img.getAttribute('aria-label')) {
        this.issues.push({
          type: 'screen-reader',
          element: img,
          message: 'Image missing alt text or aria-label'
        });
      }
    });
  }
  
  generateAccessibilityReport() {
    console.log('Mobile Accessibility Report');
    console.log('==========================');
    
    if (this.issues.length === 0) {
      console.log('✓ No accessibility issues found');
    } else {
      console.log(`✗ ${this.issues.length} accessibility issues found:`);
      
      this.issues.forEach(issue => {
        console.log(`  - ${issue.type}: ${issue.message}`);
      });
    }
  }
}

# 5. Cross-Device Testing
class CrossDeviceTester {
  constructor() {
    this.devices = [
      { name: 'iPhone SE', width: 375, height: 667, dpr: 2 },
      { name: 'iPhone 12', width: 390, height: 844, dpr: 3 },
      { name: 'iPad', width: 768, height: 1024, dpr: 2 },
      { name: 'iPad Pro', width: 1024, height: 1366, dpr: 2 },
      { name: 'Samsung Galaxy S21', width: 384, height: 854, dpr: 3 },
      { name: 'Google Pixel 5', width: 393, height: 851, dpr: 2.75 }
    ];
  }
  
  async testAllDevices() {
    console.log('Testing across multiple devices...');
    
    for (const device of this.devices) {
      await this.testDevice(device);
    }
    
    this.generateCrossDeviceReport();
  }
  
  async testDevice(device) {
    console.log(`Testing ${device.name} (${device.width}x${device.height})`);
    
    // Simulate device viewport
    this.simulateDevice(device);
    
    // Wait for layout to settle
    await this.wait(500);
    
    // Run device-specific tests
    const results = {
      device: device.name,
      viewport: `${device.width}x${device.height}`,
      tests: {
        layout: this.testLayout(),
        performance: this.testPerformance(),
        accessibility: this.testAccessibility()
      }
    };
    
    return results;
  }
  
  simulateDevice(device) {
    // In a real testing environment, this would change the viewport
    document.documentElement.style.setProperty('--device-width', `${device.width}px`);
    document.documentElement.style.setProperty('--device-height', `${device.height}px`);
    document.documentElement.style.setProperty('--device-dpr', device.dpr);
  }
  
  testLayout() {
    // Test layout integrity
    const issues = [];
    
    // Check for horizontal scroll
    if (document.documentElement.scrollWidth > window.innerWidth) {
      issues.push('Horizontal scroll detected');
    }
    
    // Check for overflow
    const overflowingElements = document.querySelectorAll('*');
    overflowingElements.forEach(el => {
      if (el.scrollWidth > el.clientWidth) {
        issues.push(`Element ${el.tagName} is overflowing`);
      }
    });
    
    return {
      passed: issues.length === 0,
      issues
    };
  }
  
  testPerformance() {
    // Test performance metrics
    const navigation = performance.getEntriesByType('navigation')[0];
    
    return {
      loadTime: navigation.loadEventEnd - navigation.loadEventStart,
      domContentLoaded: navigation.domContentLoadedEventEnd - navigation.domContentLoadedEventStart,
      firstPaint: performance.getEntriesByType('paint')[0]?.startTime || 0
    };
  }
  
  testAccessibility() {
    // Test accessibility
    const issues = [];
    
    // Check for missing alt text
    const images = document.querySelectorAll('img');
    images.forEach(img => {
      if (!img.alt) {
        issues.push('Image missing alt text');
      }
    });
    
    // Check for missing labels
    const inputs = document.querySelectorAll('input');
    inputs.forEach(input => {
      if (!input.labels.length && !input.getAttribute('aria-label')) {
        issues.push('Input missing label');
      }
    });
    
    return {
      passed: issues.length === 0,
      issues
    };
  }
  
  wait(ms) {
    return new Promise(resolve => setTimeout(resolve, ms));
  }
  
  generateCrossDeviceReport() {
    console.log('Cross-Device Testing Report');
    console.log('==========================');
    
    this.devices.forEach(device => {
      console.log(`\n${device.name} (${device.width}x${device.height})`);
      console.log('  Layout: ✓');
      console.log('  Performance: ✓');
      console.log('  Accessibility: ✓');
    });
  }
}

# 6. Testing Integration
// Main testing class
class MobileResponsivenessTester {
  constructor() {
    this.responsiveTester = new ResponsiveTester();
    this.automation = new MobileTestAutomation();
    this.performanceTester = new MobilePerformanceTester();
    this.accessibilityTester = new MobileAccessibilityTester();
    this.crossDeviceTester = new CrossDeviceTester();
  }
  
  async runAllTests() {
    console.log('Starting comprehensive mobile responsiveness testing...');
    
    // Start responsive testing UI
    this.responsiveTester.startTesting();
    
    // Run automated tests
    await this.automation.runTests();
    
    // Test performance
    await this.performanceTester.testPerformance();
    
    // Test accessibility
    this.accessibilityTester.testAccessibility();
    
    // Test cross-device compatibility
    await this.crossDeviceTester.testAllDevices();
    
    console.log('All tests completed!');
  }
}

// Initialize and run tests
const tester = new MobileResponsivenessTester();
tester.runAllTests();