1327 |
1336 |
1328 test.Next(_L("format locked card")); |
1337 test.Next(_L("format locked card")); |
1329 r = fmt.Open(fs, driveName, EHighDensity, stepPkg()); |
1338 r = fmt.Open(fs, driveName, EHighDensity, stepPkg()); |
1330 if (r != KErrLocked) |
1339 if (r != KErrLocked) |
1331 test.Printf(_L("RFormat::Next() returned %d\n"), r); |
1340 test.Printf(_L("RFormat::Next() returned %d\n"), r); |
1332 test(r == KErrLocked); |
1341 test_Value(r, r == KErrLocked); |
1333 |
1342 |
1334 test.Printf(_L("\n")); |
1343 test.Printf(_L("\n")); |
1335 fmt.Close(); |
1344 fmt.Close(); |
1336 |
1345 |
1337 _LIT(KLitStars,"********************"); |
1346 _LIT(KLitStars,"********************"); |
1338 test.Next(_L("force erase locked card")); |
1347 test.Next(_L("force erase locked card")); |
1339 r = fmt.Open(fs, driveName, EHighDensity | EForceErase, stepPkg()); |
1348 r = fmt.Open(fs, driveName, EHighDensity | EForceErase, stepPkg()); |
1340 if (r != KErrNone) |
1349 if (r != KErrNone) |
1341 test.Printf(_L("RFormat::Open() returned %d\n"), r); |
1350 test.Printf(_L("RFormat::Open() returned %d\n"), r); |
1342 test (r == KErrNone); |
1351 test_KErrNone(r); |
1343 |
1352 |
1344 while (stepPkg() > 0) |
1353 while (stepPkg() > 0) |
1345 { |
1354 { |
1346 TRequestStatus status; |
1355 TRequestStatus status; |
1347 fmt.Next(stepPkg, status); |
1356 fmt.Next(stepPkg, status); |
1386 test(TBLD.PasswordStoreLengthInBytes() == 0); |
1395 test(TBLD.PasswordStoreLengthInBytes() == 0); |
1387 |
1396 |
1388 test.Next(_L("lock card")); |
1397 test.Next(_L("lock card")); |
1389 test.Next(_L("assign test password")); |
1398 test.Next(_L("assign test password")); |
1390 r = TBLD.SetPassword(nulPWrd, testPassword, EFalse); |
1399 r = TBLD.SetPassword(nulPWrd, testPassword, EFalse); |
1391 test(r == KErrNone); |
1400 test_KErrNone(r); |
1392 |
1401 |
1393 RemountMedia(); // card is now locked |
1402 RemountMedia(); // card is now locked |
1394 |
1403 |
1395 // test Caps() reports that card is locked |
1404 // test Caps() reports that card is locked |
1396 test.Next(_L("test card is locked")); |
1405 test.Next(_L("test card is locked")); |
1397 TLocalDriveCapsV5 driveCaps; |
1406 TLocalDriveCapsV5 driveCaps; |
1398 TPckg<TLocalDriveCapsV5> driveCapsPkg(driveCaps); |
1407 TPckg<TLocalDriveCapsV5> driveCapsPkg(driveCaps); |
1399 r = TBLD.Caps(driveCapsPkg); |
1408 r = TBLD.Caps(driveCapsPkg); |
1400 test.Printf(_L("Caps() returned %d , iMediaAtt %08x\n"), r, driveCaps.iMediaAtt); |
1409 test.Printf(_L("Caps() returned %d , iMediaAtt %08x\n"), r, driveCaps.iMediaAtt); |
1401 |
1410 |
1402 test (r == KErrNone); |
1411 test_KErrNone(r); |
1403 test ((driveCaps.iMediaAtt & KMediaAttLocked) != 0); |
1412 test ((driveCaps.iMediaAtt & KMediaAttLocked) != 0); |
1404 |
1413 |
1405 // Write correct password to store |
1414 // Write correct password to store |
1406 test.Next(_L("write correct password to store")); |
1415 test.Next(_L("write correct password to store")); |
1407 |
1416 |
1655 // Lock card (with password stored) |
1664 // Lock card (with password stored) |
1656 test.Next(_L("Locking Card - Password Stored")); |
1665 test.Next(_L("Locking Card - Password Stored")); |
1657 |
1666 |
1658 test.Next(_L("Locking card (Successful)")) ; |
1667 test.Next(_L("Locking card (Successful)")) ; |
1659 r = TestLockCard(fs, RFsDNum, oldpassword, password, ETrue); |
1668 r = TestLockCard(fs, RFsDNum, oldpassword, password, ETrue); |
1660 test(r == KErrNone); |
1669 test_KErrNone(r); |
1661 |
1670 |
1662 test(!TestLocked(fs, RFsDNum)); // not locked yet as stack hasn't powered down |
1671 test(!TestLocked(fs, RFsDNum)); // not locked yet as stack hasn't powered down |
1663 |
1672 |
1664 test.Next(_L("Card reports unlocked - before PowerDown")); |
1673 test.Next(_L("Card reports unlocked - before PowerDown")); |
1665 r = TBLD.Caps(driveCapsPkg); |
1674 r = TBLD.Caps(driveCapsPkg); |
1666 test.Printf(_L("\tCaps() returned %d , iMediaAtt %08x\n"), r, driveCaps.iMediaAtt); |
1675 test.Printf(_L("\tCaps() returned %d , iMediaAtt %08x\n"), r, driveCaps.iMediaAtt); |
1667 |
1676 |
1668 test (r == KErrNone); |
1677 test_KErrNone(r); |
1669 test ((driveCaps.iMediaAtt & KMediaAttLocked) == 0); |
1678 test ((driveCaps.iMediaAtt & KMediaAttLocked) == 0); |
1670 |
1679 |
1671 WaitForPowerDownUnlock(fs, RFsDNum); |
1680 WaitForPowerDownUnlock(fs, RFsDNum); |
1672 |
1681 |
1673 test.Next(_L("Check card reports unlocked - after PowerDown")); |
1682 test.Next(_L("Check card reports unlocked - after PowerDown")); |
1674 r = TBLD.Caps(driveCapsPkg); |
1683 r = TBLD.Caps(driveCapsPkg); |
1675 test.Printf(_L("\tCaps() returned %d , iMediaAtt %08x\n"), r, driveCaps.iMediaAtt); |
1684 test.Printf(_L("\tCaps() returned %d , iMediaAtt %08x\n"), r, driveCaps.iMediaAtt); |
1676 |
1685 |
1677 test (r == KErrNone); |
1686 test_KErrNone(r); |
1678 test ((driveCaps.iMediaAtt & KMediaAttLocked) == 0); |
1687 test ((driveCaps.iMediaAtt & KMediaAttLocked) == 0); |
1679 |
1688 |
1680 test.Next(_L("Clear password (Successful)")); |
1689 test.Next(_L("Clear password (Successful)")); |
1681 r = TestClearPassword(fs, RFsDNum, password); |
1690 r = TestClearPassword(fs, RFsDNum, password); |
1682 test(r == KErrNone); |
1691 test_KErrNone(r); |
1683 |
1692 |
1684 // Lock card (without password in store) |
1693 // Lock card (without password in store) |
1685 test.Next(_L("Locking card - Password NOT Stored")); |
1694 test.Next(_L("Locking card - Password NOT Stored")); |
1686 |
1695 |
1687 test.Next(_L("Locking card (Successful)")); |
1696 test.Next(_L("Locking card (Successful)")); |
1688 r = TestLockCard(fs, RFsDNum, oldpassword, password, EFalse); |
1697 r = TestLockCard(fs, RFsDNum, oldpassword, password, EFalse); |
1689 test(r == KErrNone); |
1698 test_KErrNone(r); |
1690 |
1699 |
1691 test(!TestLocked(fs, RFsDNum)); // not locked yet as stack hasn't powered down |
1700 test(!TestLocked(fs, RFsDNum)); // not locked yet as stack hasn't powered down |
1692 |
1701 |
1693 test.Next(_L("Card is reports Unlocked - before PowerDown")); |
1702 test.Next(_L("Card is reports Unlocked - before PowerDown")); |
1694 r = TBLD.Caps(driveCapsPkg); |
1703 r = TBLD.Caps(driveCapsPkg); |
1695 test.Printf(_L("\tCaps() returned %d , iMediaAtt %08x\n"), r, driveCaps.iMediaAtt); |
1704 test.Printf(_L("\tCaps() returned %d , iMediaAtt %08x\n"), r, driveCaps.iMediaAtt); |
1696 |
1705 |
1697 test (r == KErrNone); |
1706 test_KErrNone(r); |
1698 test ((driveCaps.iMediaAtt & KMediaAttLocked) == 0); |
1707 test ((driveCaps.iMediaAtt & KMediaAttLocked) == 0); |
1699 |
1708 |
1700 WaitForPowerDownLock(fs, RFsDNum); |
1709 WaitForPowerDownLock(fs, RFsDNum); |
1701 |
1710 |
1702 test.Next(_L("Card reports Locked - after PowerDown")); |
1711 test.Next(_L("Card reports Locked - after PowerDown")); |
1703 r = TBLD.Caps(driveCapsPkg); |
1712 r = TBLD.Caps(driveCapsPkg); |
1704 test.Printf(_L("\tCaps() returned %d , iMediaAtt %08x\n"), r, driveCaps.iMediaAtt); |
1713 test.Printf(_L("\tCaps() returned %d , iMediaAtt %08x\n"), r, driveCaps.iMediaAtt); |
1705 |
1714 |
1706 test (r == KErrNone); |
1715 test_KErrNone(r); |
1707 test ((driveCaps.iMediaAtt & KMediaAttLocked) != 0); |
1716 test ((driveCaps.iMediaAtt & KMediaAttLocked) != 0); |
1708 |
1717 |
1709 // Unlock card |
1718 // Unlock card |
1710 test.Next(_L("Unlock 'locked' Card - Password Stored")); |
1719 test.Next(_L("Unlock 'locked' Card - Password Stored")); |
1711 |
1720 |
1712 test.Next(_L("Unlocking card (Successful)")) ; |
1721 test.Next(_L("Unlocking card (Successful)")) ; |
1713 r = TestUnlockCard(fs, RFsDNum, password, ETrue); |
1722 r = TestUnlockCard(fs, RFsDNum, password, ETrue); |
1714 test(r == KErrNone); |
1723 test_KErrNone(r); |
1715 test (!TestLocked(fs, RFsDNum)); // not locked as stack hasn't powered down |
1724 test (!TestLocked(fs, RFsDNum)); // not locked as stack hasn't powered down |
1716 |
1725 |
1717 test.Next(_L("Card reports unlocked - before PowerDown")); |
1726 test.Next(_L("Card reports unlocked - before PowerDown")); |
1718 r = TBLD.Caps(driveCapsPkg); |
1727 r = TBLD.Caps(driveCapsPkg); |
1719 test.Printf(_L("\tCaps() returned %d , iMediaAtt %08x\n"), r, driveCaps.iMediaAtt); |
1728 test.Printf(_L("\tCaps() returned %d , iMediaAtt %08x\n"), r, driveCaps.iMediaAtt); |
1720 |
1729 |
1721 test (r == KErrNone); |
1730 test_KErrNone(r); |
1722 test ((driveCaps.iMediaAtt & KMediaAttLocked) == 0); |
1731 test ((driveCaps.iMediaAtt & KMediaAttLocked) == 0); |
1723 |
1732 |
1724 WaitForPowerDownUnlock(fs, RFsDNum); |
1733 WaitForPowerDownUnlock(fs, RFsDNum); |
1725 |
1734 |
1726 test.Next(_L("Card reports unlocked - after PowerDown")); |
1735 test.Next(_L("Card reports unlocked - after PowerDown")); |
1727 r = TBLD.Caps(driveCapsPkg); |
1736 r = TBLD.Caps(driveCapsPkg); |
1728 test.Printf(_L("\tCaps() returned %d , iMediaAtt %08x\n"), r, driveCaps.iMediaAtt); |
1737 test.Printf(_L("\tCaps() returned %d , iMediaAtt %08x\n"), r, driveCaps.iMediaAtt); |
1729 |
1738 |
1730 test (r == KErrNone); |
1739 test_KErrNone(r); |
1731 test ((driveCaps.iMediaAtt & KMediaAttLocked) == 0); |
1740 test ((driveCaps.iMediaAtt & KMediaAttLocked) == 0); |
1732 |
1741 |
1733 test.Next(_L("Clearing Password (Successful)")); |
1742 test.Next(_L("Clearing Password (Successful)")); |
1734 r = TestClearPassword(fs, RFsDNum, password); |
1743 r = TestClearPassword(fs, RFsDNum, password); |
1735 test(r == KErrNone); |
1744 test_KErrNone(r); |
1736 |
1745 |
1737 fs.Close(); |
1746 fs.Close(); |
1738 |
1747 |
1739 test.End(); |
1748 test.End(); |
1740 } |
1749 } |
1755 TMediaPassword oldpassword; |
1764 TMediaPassword oldpassword; |
1756 TMediaPassword newpassword = (TUint8*) "salasana"; |
1765 TMediaPassword newpassword = (TUint8*) "salasana"; |
1757 TMediaPassword wrongpwd = (TUint8*) "failtest"; |
1766 TMediaPassword wrongpwd = (TUint8*) "failtest"; |
1758 |
1767 |
1759 r = TestLockCard(fs, RFsDNum, oldpassword, newpassword, EFalse); |
1768 r = TestLockCard(fs, RFsDNum, oldpassword, newpassword, EFalse); |
1760 test(r == KErrNone); |
1769 test_KErrNone(r); |
1761 test(!TestLocked(fs, RFsDNum)); // not locked yet as stack hasn't powered down |
1770 test(!TestLocked(fs, RFsDNum)); // not locked yet as stack hasn't powered down |
1762 |
1771 |
1763 test.Next(_L("test unlocking fails if still powered up")); |
1772 test.Next(_L("test unlocking fails if still powered up")); |
1764 r = TestUnlockCard(fs, RFsDNum, newpassword, EFalse); |
1773 r = TestUnlockCard(fs, RFsDNum, newpassword, EFalse); |
1765 test(r == KErrAlreadyExists); // already unlocked (as stack won't have powered down yet) |
1774 test_Value(r, r == KErrAlreadyExists); // already unlocked (as stack won't have powered down yet) |
1766 test (!TestLocked(fs, RFsDNum)); |
1775 test (!TestLocked(fs, RFsDNum)); |
1767 |
1776 |
1768 test.Next(_L("test clearing succeeds if still powered up")); |
1777 test.Next(_L("test clearing succeeds if still powered up")); |
1769 r = TestClearPassword(fs, RFsDNum, newpassword); |
1778 r = TestClearPassword(fs, RFsDNum, newpassword); |
1770 test(r == KErrNone); |
1779 test_KErrNone(r); |
1771 test(!TestLocked(fs, RFsDNum)); |
1780 test(!TestLocked(fs, RFsDNum)); |
1772 |
1781 |
1773 test.Next(_L("test locking card again")); |
1782 test.Next(_L("test locking card again")); |
1774 r = TestLockCard(fs, RFsDNum, oldpassword, newpassword, EFalse); |
1783 r = TestLockCard(fs, RFsDNum, oldpassword, newpassword, EFalse); |
1775 test(r == KErrNone); |
1784 test_KErrNone(r); |
1776 test(!TestLocked(fs, RFsDNum)); // not locked yet as stack hasn't powered down |
1785 test(!TestLocked(fs, RFsDNum)); // not locked yet as stack hasn't powered down |
1777 |
1786 |
1778 WaitForPowerDownLock(fs, RFsDNum); |
1787 WaitForPowerDownLock(fs, RFsDNum); |
1779 |
1788 |
1780 // DEF111681: CheckDisk is returning bad error code when run on locked SD card |
1789 // DEF111681: CheckDisk is returning bad error code when run on locked SD card |
1786 WaitForPowerDownLock(fs, RFsDNum); |
1795 WaitForPowerDownLock(fs, RFsDNum); |
1787 TFileName sessionPath; |
1796 TFileName sessionPath; |
1788 sessionPath=_L("?:\\"); |
1797 sessionPath=_L("?:\\"); |
1789 TChar driveLetter; |
1798 TChar driveLetter; |
1790 r = fs.DriveToChar(RFsDNum,driveLetter); |
1799 r = fs.DriveToChar(RFsDNum,driveLetter); |
1791 test(r==KErrNone); |
1800 test_KErrNone(r); |
1792 sessionPath[0]=(TText)driveLetter; |
1801 sessionPath[0]=(TText)driveLetter; |
1793 r = fs.CheckDisk(sessionPath); |
1802 r = fs.CheckDisk(sessionPath); |
1794 test(r == KErrNone || r == KErrLocked); |
1803 test_Value(r, r == KErrNone || r == KErrLocked); |
1795 WaitForPowerDownLock(fs, RFsDNum); |
1804 WaitForPowerDownLock(fs, RFsDNum); |
1796 |
1805 |
1797 |
1806 |
1798 // DEF111700: Formatting a locked SD/MMC leaves it in a bad state (causes panics later) |
1807 // DEF111700: Formatting a locked SD/MMC leaves it in a bad state (causes panics later) |
1799 // This was caused by format calling TDrive::MountMedia(ETrue) and then not dismounting |
1808 // This was caused by format calling TDrive::MountMedia(ETrue) and then not dismounting |
1800 r = fs.RemountDrive(RFsDNum); |
1809 r = fs.RemountDrive(RFsDNum); |
1801 test (r == KErrNone); |
1810 test_KErrNone(r); |
1802 RFormat fmt; |
1811 RFormat fmt; |
1803 TPckgBuf<TInt> stepPkg; |
1812 TPckgBuf<TInt> stepPkg; |
1804 TDriveUnit driveUnit(RFsDNum); |
1813 TDriveUnit driveUnit(RFsDNum); |
1805 TDriveName driveName = driveUnit.Name(); |
1814 TDriveName driveName = driveUnit.Name(); |
1806 test.Next(_L("format locked card")); |
1815 test.Next(_L("format locked card")); |
1807 r = fmt.Open(fs, driveName, EHighDensity, stepPkg()); |
1816 r = fmt.Open(fs, driveName, EHighDensity, stepPkg()); |
1808 if (r != KErrLocked) |
1817 if (r != KErrLocked) |
1809 test.Printf(_L("RFormat::Next() returned %d\n"), r); |
1818 test.Printf(_L("RFormat::Next() returned %d\n"), r); |
1810 test(r == KErrLocked); |
1819 test_Value(r, r == KErrLocked); |
1811 test.Printf(_L("\n")); |
1820 test.Printf(_L("\n")); |
1812 fmt.Close(); |
1821 fmt.Close(); |
1813 r = fs.CheckDisk(sessionPath); |
1822 r = fs.CheckDisk(sessionPath); |
1814 test(r == KErrLocked); |
1823 test_Value(r, r == KErrLocked); |
1815 |
1824 |
1816 |
1825 |
1817 test.Next(_L("test unlocking fails after powered down & unlocked with wrong password")); |
1826 test.Next(_L("test unlocking fails after powered down & unlocked with wrong password")); |
1818 r = TestUnlockCard(fs, RFsDNum, wrongpwd, EFalse); |
1827 r = TestUnlockCard(fs, RFsDNum, wrongpwd, EFalse); |
1819 test(r == KErrAccessDenied); // unlocked should now fail |
1828 test_Value(r, r == KErrAccessDenied); // unlocked should now fail |
1820 |
1829 |
1821 test.Next(_L("test unlocking succeeds for correct password after powered down & locked")); |
1830 test.Next(_L("test unlocking succeeds for correct password after powered down & locked")); |
1822 r = TestUnlockCard(fs, RFsDNum, newpassword, EFalse); |
1831 r = TestUnlockCard(fs, RFsDNum, newpassword, EFalse); |
1823 test(r == KErrNone); // unlocked should now succeed |
1832 test_KErrNone(r); // unlocked should now succeed |
1824 |
1833 |
1825 test.Next(_L("test unlocking fails after successful unlock")); |
1834 test.Next(_L("test unlocking fails after successful unlock")); |
1826 r = TestUnlockCard(fs, RFsDNum, wrongpwd, EFalse); |
1835 r = TestUnlockCard(fs, RFsDNum, wrongpwd, EFalse); |
1827 test(r == KErrAlreadyExists); // unlocked should now succeed |
1836 test_Value(r, r == KErrAlreadyExists); // unlocked should now succeed |
1828 test(!TestLocked(fs, RFsDNum)); // not locked yet as stack hasn't powered down |
1837 test(!TestLocked(fs, RFsDNum)); // not locked yet as stack hasn't powered down |
1829 |
1838 |
1830 test.Next(_L("test locking card with new password (with wrong password as old password)")); |
1839 test.Next(_L("test locking card with new password (with wrong password as old password)")); |
1831 r = TestLockCard(fs, RFsDNum, wrongpwd, newpassword, EFalse); |
1840 r = TestLockCard(fs, RFsDNum, wrongpwd, newpassword, EFalse); |
1832 test(r == KErrAccessDenied); |
1841 test_Value(r, r == KErrAccessDenied); |
1833 test(!TestLocked(fs, RFsDNum)); // not locked yet as stack hasn't powered down |
1842 test(!TestLocked(fs, RFsDNum)); // not locked yet as stack hasn't powered down |
1834 |
1843 |
1835 test.Next(_L("test locking card with new password (with right password as old password)")); |
1844 test.Next(_L("test locking card with new password (with right password as old password)")); |
1836 r = TestLockCard(fs, RFsDNum, newpassword, wrongpwd, EFalse); |
1845 r = TestLockCard(fs, RFsDNum, newpassword, wrongpwd, EFalse); |
1837 test(r == KErrNone); |
1846 test_KErrNone(r); |
1838 test(!TestLocked(fs, RFsDNum)); // not locked yet as stack hasn't powered down |
1847 test(!TestLocked(fs, RFsDNum)); // not locked yet as stack hasn't powered down |
1839 |
1848 |
1840 WaitForPowerDownLock(fs, RFsDNum); |
1849 WaitForPowerDownLock(fs, RFsDNum); |
1841 |
1850 |
1842 test.Next(_L("test clearing fails with wrong password if powered down & locked")); |
1851 test.Next(_L("test clearing fails with wrong password if powered down & locked")); |
1843 r = TestClearPassword(fs, RFsDNum, newpassword); // Note: we have set the wrong password as the new password |
1852 r = TestClearPassword(fs, RFsDNum, newpassword); // Note: we have set the wrong password as the new password |
1844 test(r == KErrAccessDenied); |
1853 test_Value(r, r == KErrAccessDenied); |
1845 test(TestLocked(fs, RFsDNum)); |
1854 test(TestLocked(fs, RFsDNum)); |
1846 |
1855 |
1847 test.Next(_L("test clearing succeeds with right password if powered down & locked")); |
1856 test.Next(_L("test clearing succeeds with right password if powered down & locked")); |
1848 r = TestClearPassword(fs, RFsDNum, wrongpwd); |
1857 r = TestClearPassword(fs, RFsDNum, wrongpwd); |
1849 test(r == KErrNone); |
1858 test_KErrNone(r); |
1850 test(!TestLocked(fs, RFsDNum)); |
1859 test(!TestLocked(fs, RFsDNum)); |
1851 |
1860 |
1852 test.Next(_L("test locking card again")); |
1861 test.Next(_L("test locking card again")); |
1853 r = TestLockCard(fs, RFsDNum, oldpassword, newpassword, EFalse); |
1862 r = TestLockCard(fs, RFsDNum, oldpassword, newpassword, EFalse); |
1854 test(r == KErrNone); |
1863 test_KErrNone(r); |
1855 test(!TestLocked(fs, RFsDNum)); // not locked yet as stack hasn't powered down |
1864 test(!TestLocked(fs, RFsDNum)); // not locked yet as stack hasn't powered down |
1856 |
1865 |
1857 test.Next(_L("test forced erase fails if still powered up")); |
1866 test.Next(_L("test forced erase fails if still powered up")); |
1858 r = ExecuteForcedEraseTestL(fs, RFsDNum); |
1867 r = ExecuteForcedEraseTestL(fs, RFsDNum); |
1859 test(r == KErrAccessDenied); // fails because card is not yet locked |
1868 test_Value(r, r == KErrAccessDenied); // fails because card is not yet locked |
1860 |
1869 |
1861 WaitForPowerDownLock(fs, RFsDNum); |
1870 WaitForPowerDownLock(fs, RFsDNum); |
1862 |
1871 |
1863 |
1872 |
1864 test.Next(_L("test forced erase succeeds if powered down & locked")); |
1873 test.Next(_L("test forced erase succeeds if powered down & locked")); |
1865 r = ExecuteForcedEraseTestL(fs, RFsDNum); |
1874 r = ExecuteForcedEraseTestL(fs, RFsDNum); |
1866 test(r == KErrNone); |
1875 test_KErrNone(r); |
1867 |
1876 |
1868 fs.Close(); |
1877 fs.Close(); |
1869 test.End(); |
1878 test.End(); |
1870 } |
1879 } |
1871 |
1880 |