code. compile. run. debug. share.
/**
*
*/
//package finalProject;
import java.io.IOException;
import java.util.Scanner;
/**
* Description: Credit Card Verification program will validate a credit card
* number or a file of credit card number based on Luhn Formula
* Class:Spring-COSC 1437.81002 Assignment: Final Project Date: 05/09/2017
* @author nguyen
* @version 05/09/2017
*/
public class Main {
/**
* Entry to program
*
* @param args
* ^accept argument from command line
* @throws IOException
* ^ if the named file exists but is a directory rather than a
* regular file, does not exist but cannot be created, or cannot
* be opened for any other reaso
* @throws NotCreditCardNumberFormat
* ^If String object referenced by cardNumberStr contains a non
* numeric character.
*/
public static void main(String[] args) throws IOException, NotCreditCardNumberFormat {
// call method welcome() to introduce and give instruction to user
welcome();
String option; // store user's option ( 1,2,3 one, two,three
String exit;// user's option of continue or exit program
// Create an CreditCardInfo variable case MobiusDuck to reference
// CreditCardInfo object
CreditCardInfo caseMobiusDuck = new CreditCardInfo();
// Create an CreditCardValidator variable validator to reference
// CreditCardValidator object
// and call CreditCardValidator constructor receives a parameter type
// CreditCardValidator caseMobiusDuck
CreditCardValidator validator = new CreditCardValidator(caseMobiusDuck);
// Create Scanner variable keyboard to reference a Scanner object
Scanner keyboard = new Scanner(System.in);
// Ask user option they one to chose
// option 1: verify a specific number they enter from keyboard
// option 2: verify a file of credit card numbers.
// option 3: exit program
System.out.print("Chose option: ");
// get option
option = keyboard.nextLine();
processUserOption(option, validator);
// ask user to continue or quit program
System.out.print("Do you want to continue( yes/no):");
// get user's option to continue program
exit = keyboard.nextLine();
while (exit.equalsIgnoreCase("YES") || exit.equalsIgnoreCase("Y")) {
System.out.print("Chose option: ");
// get user's option
option = keyboard.nextLine();
processUserOption(option, validator);
System.out.print("Do you want to continue( yes/no):");
// get user's option to continue or quit
exit = keyboard.nextLine();
}
System.out.println("\t\t Exit!\n\tThanks for using my program");
System.exit(0);
}// end of main
private static void welcome() {
System.out.println("*****************************************************");
System.out.println("********************** Welcome **********************");
System.out.printf("*%51s*\n", ' ');
System.out.println("* CREDIT CARD VERIFICATION *");
System.out.printf("*%51s*\n", ' ');
System.out.println("*****************************************************");
System.out.println("*****************************************************\n");
System.out.println("This application will verify credit card numbers");
System.out.println("Option 1: Validate a credit card number");
System.out.println("Option 2: Validate a file of credit card numbers");
System.out.println("Option 3: Exit Program\n");
}
private static void processUserOption(String option, CreditCardValidator validator)
throws IOException, NotCreditCardNumberFormat {
// check if user enter option in a digit or a string
if (Character.isDigit(option.charAt(0))) {
// if option is 1
if (Integer.parseInt(option) == 1) {
// call method creditCardNumberValidator()
// This method from CreditCardValidator class will ask user for
// a specific number to validate
validator.creditCardNumberValidator();
}
// if option is 2
else if (Integer.parseInt(option) == 2) {
// call method creditCardFileValidator. This method will ask
// user for a file that contains
// the number of Credit card number needed to be verified
// then write the result into 2 different files for valid number
// and invalid number
validator.creditCardFileValidator();
} else if (Integer.parseInt(option) == 3) {
System.out.println("\t\t Exit!\n\tThanks for using my program");
System.exit(0);
} else {
// if option is different from 1, 2,3
// Tell user it is not a valid choice
System.out.println("Sorry! We don't offer this option.\n");
}
}
// if option is a string
else {
// if option is "one"
if (option.equalsIgnoreCase("ONE")) {// this method ignore upper
// case or lower case
// call method creditCardNumberValidator()
// This method from CreditCardValidator class will ask user for
// a specific number to validate
validator.creditCardNumberValidator();
}
// if option is "two"
else if (option.equalsIgnoreCase("TWO")) {
// call method creditCardFileValidator. This method will ask
// user for a file that contains
// the number of Credit card number needed to be verified then
// write the result into 2 different files
validator.creditCardFileValidator();
} else if (option.equalsIgnoreCase("THREE")) {
System.out.println("\t\t Exit!\n\tThanks for using my program");
System.exit(0);
}
else {
// if option is different from "one" or "two"
// Tell user it is not a valid choice
System.out.println("Sorry! We don't offer this option.");
}
}
}
}
/**
*
*/
//package finalProject;
/**
* CreditCardInfo class is an subclass of Issuer class. CreditCardInfo contains
* methods that stores and return a credit card number(a string) and provides
* methods to validate a credit card number
*
* @author nguyen
* @version 05/06/2017
*
*/
public class CreditCardInfo extends Issuer {
private String cardNumberStr;
private int[] cardNumber;
private int size;
// private Issuer banker;
/**
* Contructor no argument
*/
public CreditCardInfo() {
super();
}
/**
* Constructor constructs a CreditCardInfo object given a string holds
* credit card number
*
* @param cardNumberStr
* ^ cardNumberStr reference a string holds credit card numbers
*/
public CreditCardInfo(String cardNumberStr) {
this.cardNumberStr = cardNumberStr;
this.size = cardNumberStr.length();
}
/**
* This method passes a reference point to parameter cardNumberStr to field
* cardNumberStr and store the value of length of cardNumberStr String to
* field size
*
* @param cardNumberStr
* ^ cardNumberStr reference a string holds credit card numbers
*/
public void setCardNumberStr(String cardNumberStr) {
this.cardNumberStr = cardNumberStr;
this.size = cardNumberStr.length();
}
/**
* This method return a reference of a String object that is pointed by
* field cardNumberStr
*
* @return cardNumberStr String
*/
public String getCardNumberStr() {
return cardNumberStr;
}
/**
* This method will validate cardNumberStr to determine cardNumberStr is a
* valid credit card number or not
*
* @return true if cardNumberStr is a valid credit card number, if not
* return false
* @throws NotCreditCardNumberFormat
* ^If String object referenced by cardNumberStr contains a non
* numeric character.
*/
public boolean isValidCreditCardNumber() throws NotCreditCardNumberFormat {
final int MIN_SIZE = 13;
final int MAX_SIZE = 19;
// convert cardnumberStr into digit in reversed order
// before calling function checkValid
convertToIntArray();
if (size >= MIN_SIZE && size <= MAX_SIZE) {
// If It is possible an CreditCardNumber
return checkValid();
} else {
return checkValid();
}
}
/**
* This method will do operation on cardNumber int Array which is an array
* of digits of credit card number in reversed order. This method will
* validate an credit card number
*
* @return boolean isValid
* @throws NotCreditCardNumberFormat
* ^If String object referenced by cardNumberStr contains a non
* numeric character.
*/
private boolean checkValid() {
// convert original number cardNumberStr into a int array cardNumber[]
// with reversed order
// Original Number(String cardNumberStr): 4 5 5 6 7 3 7 5 8 6 8 9 9 8 5
// 5
// after calling function convertToIntArray,
// int cardNumber[]: 5 5 8 9 9 8 6 8 5 7 4 7 6 5 5 4
// the first element cardNumber[0]=5
// checkValid() method will work on cardNumber[1] to the last element
int checkDigit = 0; // is the amount that you would need to add to get a
// multiple of 10 (Modulo 10)
int sum = 0; // to hold the sum of all numbers in reverse array
for (int i = 1; i < size; i++) {// cardNumber[0]= the last digit on
// credit card
// multiply cardNumber at add even position(or an odd index) by 2.
if (i % 2 != 0) {
cardNumber[i] = cardNumber[i] * 2;
// if result is greater than 9, minus the result by 9
if (cardNumber[i] > 9) {
cardNumber[i] = cardNumber[i] - 9;
} // end if
} // end if
sum = sum + cardNumber[i];
} // end of For loop
if (sum % 10 != 0) {
checkDigit = 10 - sum % 10; // Example (84+checkDigit)/10=0,
// therefore checkDigit=6
// Create Formula: remainder of 84/10=4, 10-4=6, 6+84=90,90%90=0
}
// compare the checkDigit and the last digit of the Credit Card
if (checkDigit == cardNumber[0]) {
setValidCard(cardNumberStr);
findIssuer();
return true;
} else {
return false;
}
}// end of checkValid method
/**
* convertToIntArray convert the value stored in cardNumberStr field into an
* Int array with reversed order
*
* @throws NotCreditCardNumberFormat
* ^If String object referenced by cardNumberStr contains a non
* numeric character.
*/
private void convertToIntArray() throws NotCreditCardNumberFormat {
// convert original number cardNumberStr into a int array cardNumber[]
// with reversed order
// Original Number(String cardNumberStr)4 5 5 6 7 3 7 5 8 6 8 9 9 8 5 5
// reverse order(int cardNumber[]): 5 5 8 9 9 8 6 8 5 7 4 7 6 5 5 4
// Create an int array
cardNumber = new int[size];
// Convert the line String into int array
int j = 0;
// start at the last element of cardNumberStr and go backward
for (int i = size - 1; i >= 0; i--) {
// if value at that element is a digit
if (Character.isDigit(cardNumberStr.charAt(i))) {
// convert that value into integer type and store the result to
// cardNumber
cardNumber[j] = Integer.parseInt(cardNumberStr.charAt(i) + "");
j++;
} else {// if the crruent element of cardNumberStr is not a digit
// throw an exception
throw new NotCreditCardNumberFormat(cardNumberStr);
} // end else
} // end of for loop
}// end of method convertToIntArray
}
/**
*
*/
///package finalProject;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Scanner;
/**
* Description: This class can't work by itself, when creating an object, have
* to have an specific CreditCardInfo object connect to it. This class provides
* methods that interacting with user and get String input from user, Input can
* be a name of a file that hold credit card number, or input can be a specific
* credit card number that user wants it to be verified. The verified results
* will be write in to a file or print out to the screen.
*
* @author nguyen
* @version 05/05/2017
*/
public class CreditCardValidator {
private ArrayList<String> validList = new ArrayList<String>();
private ArrayList<String> invalidList = new ArrayList<String>();
private CreditCardInfo detector;// reference CreditCardInfo object
/**
* Constructor constructs a CreditCardValidator object given a
* CreditCardInfo object
*
* @param detector
* ^variable reference an CreditCardInfo object
*/
public CreditCardValidator(CreditCardInfo detector) {
this.detector = detector;
}
/**
* seperateToArrayList method cheks the validation of credit card number and
* stores the result into two seperates ArrayList. validList for valid
* credit card numbers, invalidList for invalid credit card numbers
*
* @param cardNumberStr
* ^ cardNumberStr reference a string holds credit card numbers
* @throws NotCreditCardNumberFormat
* ^If String object referenced by cardNumberStr contains a non
* numeric character.
*/
public void seperateToArrayList(String cardNumberStr) throws NotCreditCardNumberFormat { // call
// method
// setCardNumberStr
// from
// CreditCardInfo
// class
// to
// store
// the
// value
// of
// cardNumberStr
// argument
// to
// the
// field
// cardNumberStr
// of
// CreditCardInfo
// class
detector.setCardNumberStr(cardNumberStr);
// call method isValidCreditCardNumber from CreditCardInfo class. This
// method will validate the cardNumberStr
// it will return true if cardNumberStr is a valid credit card number
if (detector.isValidCreditCardNumber()) {
// This is a valid card. get card number, get the Issuer and IIRANGE
// of this card, and store it to validList
validList.add(
detector.getCardNumberStr() + " " + detector.getIssuerBank() + " " + detector.getInRange());
// print out to screen
System.out.printf("%-20s%s %s\n", detector.getCardNumberStr(), detector.getIssuerBank(),
detector.getInRange());
} else {
// If this is an invalid card. store this number to ArrayList
// invalidList
invalidList.add(detector.getCardNumberStr());
// print out to screen
System.out.printf("%-20s#INVALID\n", detector.getCardNumberStr());
}
}
/**
* This method returns a reference to object is pointed by validList field
*
* @return validList ArrayList
*/
public ArrayList<String> getValidList() {
return validList;
}
/**
* This method returns a reference to object is pointed by ivalidList field
*
* @return invalidList ArrayList
*/
public ArrayList<String> getInvalidList() {
return invalidList;
}
/**
* creditCardNumberValidator method will get input from user. Input is
* string that holds a credit card number. This method then will check for
* validation of that credit card number, then print out the result to the
* screen
*/
public void creditCardNumberValidator() {
// Create Scanner variable keyboard to reference a Scanner object
Scanner keyboard = new Scanner(System.in);
// get a specific credit card number needed to be verified
System.out.println("Enter a credit card number you want to verify");
/// call method setCardNumberStr from CreditCardInfo class
// to store user's input to the field cardNumberStr of CreditCardInfo
/// class
detector.setCardNumberStr(keyboard.next());
try { // Handling exception
if (detector.isValidCreditCardNumber()) {
System.out.printf("%-20s%s %s\n\n", detector.getCardNumberStr(), detector.getIssuerBank(),
detector.getInRange());
} else {
System.out.printf("%-20s#INVALID\n\n", detector.getCardNumberStr());
}
} catch (NotCreditCardNumberFormat e) { // method when a nonnumeric data
// is found
System.out.println(e.getMessage());
} // end of catch
}// end of method
/**
* This method will get input from user. Input is a String holds name of an
* actual file that contains credit card numbers needed to be verified. This
* method then will check for validation of each of credit card number in
* the file, print out the result to the screen and write the result into 2
* different files. By default valid credit card Number will be written to
* valid_card.txt, invalid numbers will be written to invalid_numbers.txt
* file
*
* @throws IOException
* ^ if the named file exists but is a directory rather than a
* regular file, does not exist but cannot be created, or cannot
* be opened for any other reason
*/
public void creditCardFileValidator() throws IOException {
String filename;
String validFile = "valid_cards.txt";
String invalidFile = "invalid_numbers.txt";
// Creates keyboard reference Scanner object to
// read each line from the file stream.
Scanner keyboard = new Scanner(System.in);
try {//
System.out.print("Enter a file you want to process: ");
// get the file name
filename = keyboard.nextLine();
// open the file
File file = new File(filename);
Scanner inputFile = new Scanner(file);
// Process the content of the file
System.out.println("Processing...");
// Force a NotCreditCardNumber exception
try {
// read lines from the file until no more are left
while (inputFile.hasNext()) {
seperateToArrayList(inputFile.nextLine());
} // end of while
System.out.println("\n\t" + validList.size() + " VALID\t" + invalidList.size() + " INVALID");
} catch (NotCreditCardNumberFormat e) {// method when the input is
// an non numeric data
// print out its not a valid credit card number
System.out.println(e.getMessage());
}
FileWriter fWriterValid = new FileWriter(validFile);// change to new
// FileWriter(validFile,true)
// to append to
// existing file
FileWriter fWriterInvalid = new FileWriter(invalidFile);
PrintWriter outFileValid = new PrintWriter(fWriterValid);// new
// FileWriter(validFile,true);
PrintWriter outFileInvalid = new PrintWriter(fWriterInvalid);
// This is enhanced for loop method, write every elements of
// ArrayList validList to validFile
for (String card : validList) {
outFileValid.println(card);
}
// This is enhanced for loop method, write every elements of
// ArrayList validList to inValidFile
for (String card : invalidList) {
outFileInvalid.println(card);
}
// Close the file
inputFile.close();
outFileValid.close();
outFileInvalid.close();
// Inform to user that process is success an show user the names of
// files
// so they can retrieve later.
System.out.println("The valid credit cards written to the file " + validFile
+ "\nThe invalid credit cards were written to the file " + invalidFile + "\n");
System.out.println("\t\t Success!\n");
} catch (FileNotFoundException e) {
// The file was not found
System.out.println("File not found");
} // end of catch
}// end of method creditCardFileValidator
}// end of class
/**
*
*/
//package finalProject;
import java.util.regex.Pattern;
/**
* Description:This class provides many methods to determine the issuer and
* IINRANGE of a valid credit card number. if issuer is not American express,
* Dinner Club, Discover, InstaPayment, MasterCard, JCB, LASER, Maestro,Visa,
* Visa electron class will return "Undefined"
*
* @author nguyen
* @version 05/05/2017
*/
public class Issuer {
private String issuerBank = "";
private String inRange = "";
private String validCard;
/**
* Constructor constructs a Issuer object
*
*/
public Issuer() {
super();
}
/**
* This method returns the value in the issuerBank field
*
* @return issuerBank String
*/
public String getIssuerBank() {
return issuerBank;
}
/**
* This method returns the value in the inRange field
*
* @return inRange
*/
public String getInRange() {
return inRange;
}
/**
* setValidCard method get valid credit card number and stores that value to
* validCard field
*
* @param validCard
* ^validCard reference an String object holds a valid credit
* card number.
*/
public void setValidCard(String validCard) {
this.validCard = validCard;
}
/*
* /**setIssuerBank store the value of parameter s to issuerBank field
*
* @param s
*
* public void setIssuerBank(String s){ issuerBank=s; } /**setInRange stores
* the value of parameter r to inRange field
*
* @param r
*
* public void setInRange(String r){ inRange=r; }
*/
/**
* findIssuer method will return the value in issuerBank field which holds
* the issuer's name of the validCard
*
* @return issuerBank String
*/
public String findIssuer() {
if (!isAmericanExpress() && !isDinnersClub() && !isDiscover() && !isInstaPayment() && !isMasterCard()
&& !isJCB() && !isLaser() && !isMaestro() && !isVisaElectron() && !isVisa()) {
issuerBank = "Undefined";
return issuerBank;
} else {
return issuerBank;
}
}// end of findIssuer method
/**
* This method validates whether a credit card is issued by American Express
* or not
*
* @return true if validCard is issued by American Express, false if not
*/
public boolean isAmericanExpress() {
// iinRange 34,37 length=15
// American Express is the only card that have length =15
if (validCard.length() == 15) {
inRange = validCard.substring(0, 2);
issuerBank = "American Express(AMEX)";
return true;
} else {
return false;
}
}// end of method americanExpressIssuer
/**
* This method validates whether a credit card is issued by Dinners Club or
* not
*
* @return true if validCard is issued by Dinner Club, false if not
*/
public boolean isDinnersClub() {
String DINERS_CLUB_INTE = "36";
String DINERS_CLUB_USA_CANA = "54";
// Diners Club - Carte Blanche 300, 301, 302, 303, 304, 305 length= 14
// Diners Club - International 36 length 14
// Diners Club - USA & Canada 54 length=16
// if length=14, it can be Carte Blanche or International
if (validCard.length() == 14) {
// if validCard start with 36 it its Diners club international
if (validCard.startsWith(DINERS_CLUB_INTE)) {
inRange = DINERS_CLUB_INTE;
issuerBank = "Dinners Club - International";
} else {
// if it is not internatinal it will be Carte Blanche
inRange = validCard.substring(0, 3);
issuerBank = "Dinners Club - Carte Blanche";
}
return true;
} else if (validCard.startsWith(DINERS_CLUB_USA_CANA)) {
inRange = DINERS_CLUB_USA_CANA;
issuerBank = "Dinners Club - North American";
return true;
} else {
return false;
} // end else
}// end method dinnerClubIssuer
/**
* This method validates whether a credit card is issued by Discover or not
*
* @return true if validCard is issued by Discover, if not false
*/
public boolean isDiscover() {
// Discover 6011, 622126 to 622925, 644, 645, 646,
// 647, 648, 649, 65
if (validCard.startsWith("6011")) {
inRange = "6011";
issuerBank = "Discover";
return true;
} else if (validCard.startsWith("65")) {
inRange = "65";
issuerBank = "Discover";
return true;
} // if validCard start with a number from the range [644-649]
else if (Pattern.matches("[6][4][4-9].*", validCard)) {
inRange = validCard.substring(0, 3);
issuerBank = "Discover";
return true;
} else if (Pattern.matches("[6][2][2][1,9][2][5,6].*", validCard)) {
// Integer.parseInt(validCard.substring(0,
// 6))>=622126&&Integer.parseInt(validCard.substring(0, 6))<=622925)
inRange = validCard.substring(0, 6);
issuerBank = "Discover";
return true;
} else {
return false;
}
}
/**
* This method validates whether a credit card is issued by InstaPayment or
* not
*
* @return true if validCard is issued by InstaPayment, if not: false
*/
public boolean isInstaPayment() {
// InstaPayment 637, 638, 639 length 16
if (Pattern.matches("[6][3][7-9].*", validCard)) {
// if
// (validCard.startsWith("637")||validCard.startsWith("638")||validCard.startsWith("639")){
// inRange is the first 3 number of validCard
inRange = validCard.substring(0, 3);
issuerBank = "InstaPayment";
return true;
} else {
return false;
}
}// end of method isInstalPayment
/**
* This method validates whether a credit card is issued by JCB or not
*
* @return true if validCard is issued by JCB, if not: false
*/
public boolean isJCB() {
// JCB 3528 to 3589 length 16
if (Pattern.matches("[3][5][2,8][8,9].*", validCard)) {
inRange = validCard.substring(0, 4);
issuerBank = "JCB";
return true;
} else {
return false;
}
}// end of method isJCB
/**
* This method validates whether a credit card is issued by LASER or not
*
* @return true if validCard is issued by LASER, if not false
*/
public boolean isLaser() {
// String[] laser={"6304","6706","6771","6709"}; length 16-19
if (Pattern.matches("[6][3,7][0,7][1,4,6,9].*", validCard)) {
inRange = validCard.substring(0, 4);
issuerBank = "LASER";
return true;
} else {
return false;
}
}// end of method is Laser
/**
* This method validates whether a credit card is issued by Maestro or not
*
* @return true if validCard is issued by Maestro, if not false
*/
public boolean isMaestro() {
String maestro[] = { "5018", "5020", "5038", "5893", "6304", "6759", "6761", "6762", "6763" };
if (searchInRange(maestro) >= 0) {
inRange = maestro[searchInRange(maestro)];
issuerBank = "Maestro";
return true;
} else {
return false;
}
}// end of method isMaestro
/**
* This method validates whether a credit card is issued by Master Card or
* not
*
* @return true if validCard is issued by isMasterCard, if not : false
*/
public boolean isMasterCard() {
if (Pattern.matches("[5][1-5].*", validCard)) {
inRange = validCard.substring(0, 2);
issuerBank = "MasterCard";
return true;
} else {
return false;
}
}// end of method isMasterCard
/**
* This method validates whether a credit card is issued by Visa Electron or
* not
*
* @return true if validCard is issued by VisaElectron, if not: false
*/
public boolean isVisaElectron() {
// Visa Electron 4026, 417500, 4508, 4844, 4913, 4917 leng16
String visaElectron[] = { "4026", "417500", "4508", "4844", "4913", "4917" };
if (searchInRange(visaElectron) >= 0) {
inRange = visaElectron[searchInRange(visaElectron)];
issuerBank = "Visa Electron";
return true;
} else {
return false;
}
}// end of method isViasElectron
/**
* This method validates whether a credit card is issued by Visa or not
*
* @return true if validCard is issued by Visa, if not false
*/
public boolean isVisa() {
if (Pattern.matches("[4].*", validCard)) {
inRange = validCard.substring(0, 1);
issuerBank = "VISA";
return true;
} else {
return false;
}
}// end of method isVisa
/**
* searchInRange method will search a specific String Array holds
* information of a Issuer's IIRANGE to find out a Iusser's IIRANGE that
* matches with the validCard. It then will return the position of that
* matched IIRANGE
*
* @param s
* is a String Array includes information of a Issuer's IIRANGE
* @return element int
*/
private int searchInRange(String[] s) {
int index, element;
boolean found;
index = 0;
element = -1;
found = false;
while (!found && index < s.length) {
if (validCard.startsWith(s[index])) {
found = true;
element = index;
}
index++;
}
return element;
}// end of searchInRange
}// end of class
/**
*
*/
//package finalProject;
/**
* Description: Signals that an attempt to validate an non numeric credit card
* number. This exception will be thrown by CreditCardInfo.convertToIntArray()
* method,CreditCardInfo.isValidCreditCardNumber()method,
* CreditCardValidator.seperateToArrayList()method
*
* @author nguyen
* @version 05/09/2017
*/
public class NotCreditCardNumberFormat extends Exception {
public NotCreditCardNumberFormat() {
super("#INVALID Not a credit card number\n");
}
/**
* The following constructor accepts the String that hold credit card number
*
* @param creditCardStr
* ^ cardNumberStr reference a string holds credit card numbers
*/
public NotCreditCardNumberFormat(String creditCardStr) {
super(creditCardStr + "\t#INVALID" + ": Nonnumeric data was found\n");
}
}
3158539628375348
3337465828248404
3112804683572030
3112804683572033
5435528978467581
6706465468107999
6304362971054667
6706169762827894
6706169762827892
4844104341377697
4913405490886727
4844885754351829
4844885754351822
6371473570875275
6381475006869978
6389057917814806
347100734345549
347100734345543
6011162533805000
6011621663574413
6011824617460743
6011824617460745
6389057917814802
4539318768050385
36880982786892
36845793345501
36661154562232
36661154562234
5893329089846994
6761680165952016
6763100400984029
6763100400984022
5127043299122389
5330838017737340
5429168755154025
5429168755154023
375354034606481
379570632133224
4485521241443135
4532916206508075
4532916206508076
5590976687287124
5540641137519895
5540641137519892
30522070708059
30066552673241
30365487186802
30365487186801
3112804683572033
6706169762827892
4844885754351822
347100734345543
6011824617460745
6389057917814802
36661154562234
6763100400984022
5429168755154023
4532916206508076
5540641137519892
30365487186801
3158539628375348 Undefined
3337465828248404 Undefined
3112804683572030 Undefined
5435528978467581 Dinners Club - North American 54
6706465468107999 LASER 6706
6304362971054667 LASER 6304
6706169762827894 LASER 6706
4844104341377697 Visa Electron 4844
4913405490886727 Visa Electron 4913
4844885754351829 Visa Electron 4844
6371473570875275 InstaPayment 637
6381475006869978 InstaPayment 638
6389057917814806 InstaPayment 638
347100734345549 American Express(AMEX) 34
6011162533805000 Discover 6011
6011621663574413 Discover 6011
6011824617460743 Discover 6011
4539318768050385 VISA 4
36880982786892 Dinners Club - International 36
36845793345501 Dinners Club - International 36
36661154562232 Dinners Club - International 36
5893329089846994 Maestro 5893
6761680165952016 Maestro 6761
6763100400984029 Maestro 6763
5127043299122389 MasterCard 51
5330838017737340 MasterCard 53
5429168755154025 Dinners Club - North American 54
375354034606481 American Express(AMEX) 37
379570632133224 American Express(AMEX) 37
4485521241443135 VISA 4
4532916206508075 VISA 4
5590976687287124 MasterCard 55
5540641137519895 MasterCard 55
30522070708059 Dinners Club - Carte Blanche 305
30066552673241 Dinners Club - Carte Blanche 300
30365487186802 Dinners Club - Carte Blanche 303
Compiling Program...
Standard Input:
Interactive Console
Text
Program is not being debugged. Click "Debug" button to start program in debug mode.
| # | Function | File:Line |
|---|
| Variable | Value |
|---|
| Register | Value |
|---|
| Expression | Value |
|---|
| # | Description |
|---|