How GitHub Copilot can help you with writing JS unit tests

function toUpperWithSharpS(input) {
  if (input != null) {
    let inputSplit = input.split(/[\ß]/)

    for (var i = 0, len = inputSplit.length; i < len; i++) {
      inputSplit[i] = inputSplit[i].toUpperCase()
    }

    return inputSplit.join("ß")
  } else {
    throw new Error("input param not specified")
  }
}

describe("toUpperWithSharpS", () => {
  it("should convert string to uppercase and keep sharp S", () => {
    const input = "straße"
    const output = toUpperWithSharpS(input)
    expect(output).toBe("STRASSE")
  })

  it("should throw an error if input is not provided", () => {
    expect(() => toUpperWithSharpS()).toThrow("input param not specified")
  })

  it("should throw an error if input is null", () => {
    expect(() => toUpperWithSharpS(null)).toThrow("input param not specified")
  })
})

describe("toUpperWithSharpS", () => {
  it("should return null when input is null", () => {
    expect(toUpperWithSharpS(null)).toBeNull()
  })

  it("should throw an error when input is not specified", () => {
    expect(() => toUpperWithSharpS()).toThrowError("input param not specified")
  })

  it("should convert lowercase ß to uppercase SS", () => {
    expect(toUpperWithSharpS("weiß")).toBe("WEISS")
  })

  it("should convert uppercase ß to uppercase SS", () => {
    expect(toUpperWithSharpS("WEIẞ")).toBe("WEISS")
  })

  it("should not convert other characters", () => {
    expect(toUpperWithSharpS("abc123!@#")).toBe("ABC123!@#")
  })

  it("should handle multiple occurrences of ß", () => {
    expect(toUpperWithSharpS("weißbier und weißwein")).toBe(
      "WEISSBIER UND WEISSWEIN",
    )
  })

  it("should handle input with no ß", () => {
    expect(toUpperWithSharpS("hello world")).toBe("HELLO WORLD")
  })
})

// toUpperWithSharpSTest.js

const { toUpperWithSharpS } = require("./path-to-your-function-file") // update the path to the file where your function is

describe("toUpperWithSharpS function", () => {
  // Standard functionality with normal input
  it("converts standard strings to uppercase while preserving sharp s", () => {
    expect(toUpperWithSharpS("helloßworld")).toBe("HELLOßWORLD")
    expect(toUpperWithSharpS("hello")).toBe("HELLO")
  })

  // Edge cases: empty strings and strings with special characters
  it("handles edge cases correctly", () => {
    expect(toUpperWithSharpS("")).toBe("")
    expect(toUpperWithSharpS("ß")).toBe("ß")
    expect(toUpperWithSharpS("helloßworldßagain")).toBe("HELLOßWORLDßAGAIN")
    expect(toUpperWithSharpS("123!@#ßabc")).toBe("123!@#ßABC")
  })

  // Handling null and undefined separately as they are different cases in JavaScript
  it("throws error when input is null", () => {
    expect(() => toUpperWithSharpS(null)).toThrowError(
      new Error("input param not specified"),
    )
  })

  it("throws error when input is undefined", () => {
    expect(() => toUpperWithSharpS(undefined)).toThrowError(
      new Error("input param not specified"),
    )
  })

  // Non-string inputs to check robustness of input validation
  it("handles non-string inputs", () => {
    expect(() => toUpperWithSharpS(123)).toThrow() // it should ideally throw a type error, but based on function implementation, behavior might differ
    expect(() => toUpperWithSharpS({})).toThrow() // expecting similar behavior for objects
    expect(() => toUpperWithSharpS(true)).toThrow() // non-string primitive
  })

  // Check with strings that contain characters from different languages
  it("handles strings with characters from different languages", () => {
    // Assuming the behavior is to keep non-English characters as they are
    expect(toUpperWithSharpS("안녕하세요ßworld")).toBe("안녕하세요ßWORLD")
    expect(toUpperWithSharpS("Приветßworld")).toBe("ПРИВЕТßWORLD")
  })
})