如何随机化字符串中字母的大小写

Question

I want to write some automated tests for web app authentication. The login password is case-sensitive and always contains at least one alphabetic character.

I want to write a test where I randomly change the case of one or more alphabetic characters.

Let's say the password string is "123te123st!" .

Now I want to change this string to one which contains at least one uppercase letter. I'm trying to make sure that the login is still case-insensitive and any variation in case will fail to match the password.

Does anybody know a elegant way to do it? I searched already (including Apache Commons) but couldn't find a helper method.

Answer 1

You can look at the randomAlphaNumeric from the RandomStringUtils , although it would seem that you are not guaranteed for it to have an upper case. To go around this, you could get the first lowercase letter and use the .toUpper() method to get it to upper case.

Alternatively, you could generate random numbers between 0 and 9 and 65 and 90 and 97 and 122. The first set should get you random numbers, you could then cast the second number to a character to get your upper case letter(s) and do the same on the last number to get your lower case ones.

That being said, when testing one usually goes for data which is predetermined rather than generating data on the fly, since that would make it easier to debug. Having a simple pool of passwords might also be easier to implement and would also allow you to better test edge cases.

Answer 2

class Case
{
  public static void main(String ar[])
  {
    String s = "upperCase",split[];
    split = s.split("");
    int len = s.length(),i=0;
    while(i!=len)
    {
        if(split[i].toUpperCase() == split[i])
        {   
            System.out.println("Password Contains One UpperCase Latter");
            break;
        }
        i++;
    }
  }
}

By using this code u can easily check whether string contain uppercase or not. if output prints "Password Contains One Uppercase Latter" this message then string contain at least on uppercase.

In this case output would like:

Answer 3

To generate all capitalized variants of a string, it makes sense to scan the string and store the position of each letter in a list. This will let you iterate over the letters while skipping the non-letter characters.

For example, for the string "_a_b_c_" , you want to store the positions [1, 3, 5] .

Next, make a boolean array of the same length as the list of letter positions. This will represent the positions of letters that have had their case inverted.

To generate the next capitalized variant, pretend that the boolean array represents a binary number in reverse. Add 1 to that boolean number, which means scanning the array from the beginning, flipping each true to false until you reach a false , which you flip to true . As you flip each bit, invert the case of the corresponding character in the string.

Thus, we get the following 2 ³ - 1 = 7 variants of "_a_b_c_" :

binary number  reversed   capitalized variant
        001       100      _A_b_c_
        010       010      _a_B_c_
        011       110      _A_B_c_
        100       001      _a_b_C_
        101       101      _A_b_C_
        110       011      _a_B_C_
        111       111      _A_B_C_

Here is a complete Java implementation.

import java.util.*;
import java.io.*;

public class VaryCaps {

  int wordLength,
      numLetters;
  Integer letterPositions[];
  boolean inverted[];
  StringBuffer buffer;

  public VaryCaps(String word) {
    wordLength = word.length();
    List<Integer> positionList = new ArrayList<Integer>();
    for (int i = 0; i < wordLength; ++i) {
      if (Character.isLetter(word.charAt(i))) {
        positionList.add(i);
      }
    }
    numLetters = positionList.size();
    letterPositions = positionList.toArray(new Integer[numLetters]);
    inverted = new boolean[numLetters];
    buffer = new StringBuffer(word);
  }

  private void invert(int index) {
    int pos = letterPositions[index];
    char ch = buffer.charAt(pos);
    if (Character.isUpperCase(ch)) {
      ch = Character.toLowerCase(ch);
    } else {
      ch = Character.toUpperCase(ch);
    }
    buffer.setCharAt(pos, ch);
    inverted[index] = !inverted[index];
  }

  public String next() {
    int index = 0;
    while (index < numLetters && inverted[index]) {
      invert(index++);
    }
    if (index == numLetters) {
      return null;
    }
    invert(index);
    return buffer.toString();
  }

  public static void main(String[] args) {
    VaryCaps rc = new VaryCaps("_a_b_c_");
    String s;
    while ((s = rc.next()) != null) {
      System.out.println(s);
    }
  }
}

Answer 4

You can try like this:

public class Test{

    public static void main(String[] args){
        String s = "1a23test12hjsd2"; // Take it as a password
        char[] c= s.toCharArray(); //Convert string in chararray
        boolean flag= false;
        StringBuilder s1= new StringBuilder();
        for(int d:c){
            if(d>=97 && d<=122 && !flag){ //Converting lowercase to upper case
                d=d-32;
                flag=true;
            }
            s1.append((char)d);
        }
        System.out.println(s1);
    }
}

Answer 5

You can use this class to generate random passwords with a constraint on uppercase letters.

import java.util.Random;

public class RandomPasswordGenerator {
    private static final String ALPHA_CAPS  = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
    private static final String ALPHA   = "abcdefghijklmnopqrstuvwxyz";
    private static final String NUM     = "0123456789";
    private static final String SPL_CHARS   = "!@#$%^&*_=+-/";

    public static char[] generatePswd(int minLen, int maxLen, int noOfCAPSAlpha, 
            int noOfDigits, int noOfSplChars) {
        if(minLen > maxLen)
            throw new IllegalArgumentException("Min. Length > Max. Length!");
        if( (noOfCAPSAlpha + noOfDigits + noOfSplChars) > minLen )
            throw new IllegalArgumentException
            ("Min. Length should be atleast sum of (CAPS, DIGITS, SPL CHARS) Length!");
        Random rnd = new Random();
        int len = rnd.nextInt(maxLen - minLen + 1) + minLen;
        char[] pswd = new char[len];
        int index = 0;
        for (int i = 0; i < noOfCAPSAlpha; i++) {
            index = getNextIndex(rnd, len, pswd);
            pswd[index] = ALPHA_CAPS.charAt(rnd.nextInt(ALPHA_CAPS.length()));
        }
        for (int i = 0; i < noOfDigits; i++) {
            index = getNextIndex(rnd, len, pswd);
            pswd[index] = NUM.charAt(rnd.nextInt(NUM.length()));
        }
        for (int i = 0; i < noOfSplChars; i++) {
            index = getNextIndex(rnd, len, pswd);
            pswd[index] = SPL_CHARS.charAt(rnd.nextInt(SPL_CHARS.length()));
        }
        for(int i = 0; i < len; i++) {
            if(pswd[i] == 0) {
                pswd[i] = ALPHA.charAt(rnd.nextInt(ALPHA.length()));
            }
        }
        return pswd;
    }

    private static int getNextIndex(Random rnd, int len, char[] pswd) {
        int index = rnd.nextInt(len);
        while(pswd[index = rnd.nextInt(len)] != 0);
        return index;
    }
}