added table test cases

deck.go

-package main
-
-import (
-	"fmt"
-	"io/ioutil"
-	"math/rand"
-	"os"
-	"strings"
-	"time"
-)
-
-// Create a new type of 'deck'
-// which is a slice of strings
-type deck []string
-
-func newDeck() deck {
-	cards := deck{}
-
-	cardSuits := []string{"Spades", "Diamonds", "Hearts", "Clubs"}
-	cardValues := []string{"Ace", "Two", "Three", "Four"}
-
-	for _, suit := range cardSuits {
-		for _, value := range cardValues {
-			cards = append(cards, value+" of "+suit)
-		}
-	}
-
-	return cards
-}
-
-func (d deck) print() {
-	for i, card := range d {
-		fmt.Println(i, card)
-	}
-}
-
-func deal(d deck, handSize int) (deck, deck) {
-	return d[:handSize], d[handSize:]
-}
-
-func (d deck) toString() string {
-	return strings.Join([]string(d), ",")
-}
-
-func (d deck) saveToFile(filename string) error {
-	return ioutil.WriteFile(filename, []byte(d.toString()), 0666)
-}
-
-func newDeckFromFile(filename string) deck {
-	bs, err := ioutil.ReadFile(filename)
-	if err != nil {
-		// Option #1 - log the error and return a call to newDeck()
-		// Option #2 - Log the error and entirely quit the program
-		fmt.Println("Error:", err)
-		os.Exit(1)
-	}
-
-	s := strings.Split(string(bs), ",")
-	return deck(s)
-}
-
-func (d deck) shuffle() {
-	source := rand.NewSource(time.Now().UnixNano())
-	r := rand.New(source)
-
-	for i := range d {
-		newPosition := r.Intn(len(d) - 1)
-
-		d[i], d[newPosition] = d[newPosition], d[i]
-	}
-}

dect_test.go

-package main
-
-import (
-	"os"
-	"testing"
-)
-
-func TestNewDeck(t *testing.T) {
-	d := newDeck()
-
-	if len(d) != 16 {
-		t.Errorf("Expected deck length of 16, but got %v", len(d))
-	}
-
-	if d[0] != "Ace of Spades" {
-		t.Errorf("Expected first card of Ace of Spades, but got %v", d[0])
-	}
-
-	if d[len(d)-1] != "Four of Clubs" {
-		t.Errorf("Expected last card of Four of Clubs, but got %v", d[len(d)-1])
-	}
-}
-
-func TestSaveToDeckAndNewDeckFromFile(t *testing.T) {
-	os.Remove("_decktesting")
-
-	deck := newDeck()
-	deck.saveToFile("_decktesting")
-
-	loadedDeck := newDeckFromFile("_decktesting")
-
-	if len(loadedDeck) != 16 {
-		t.Errorf("Expected 16 cards in deck, got %v", len(loadedDeck))
-	}
-
-	os.Remove("_decktesting")
-}
-
-// Execute test file by this command : go test

main.go

 package main
 
+import (
+	"fmt"
+	"strings"
+)
+
 func main() {
-	cards := newDeck()
-	cards.shuffle()
-	cards.print()
+	str := ToSnakeCase("helloWorld !!!")
+	fmt.Println(str)
 }
 
-// Execute commond both file like : go run main.go deck.go
+func ToSnakeCase(str string) string {
+	// step 0: handle empty string
+	if str == "" {
+		return ""
+	}
+
+	// step 1: CamelCase to snake_case
+	for i := 0; i < len(str); i++ {
+		if str[i] >= 'A' && str[i] <= 'Z' {
+			if i == 0 {
+				str = strings.ToLower(string(str[i])) + str[i+1:]
+			} else {
+				str = str[:i] + "_" + strings.ToLower(string(str[i])) + str[i+1:]
+			}
+		}
+	}
+
+	// step 2: remove spaces
+	str = strings.ReplaceAll(str, " ", "")
+
+	// step 3: remove double-underscores
+	str = strings.ReplaceAll(str, "__", "_")
+
+	return str
+}

snake_case_test.go

+package main
+
+import "testing"
+
+func TestToSnakeCase(t *testing.T) {
+	type testCase struct {
+		description string
+		input       string
+		expected    string
+	}
+
+	testCases := []testCase{
+		{
+			description: "empty string",
+			input:       "",
+			expected:    "",
+		},
+		{
+			description: "single word",
+			input:       "Hello",
+			expected:    "hello",
+		},
+		{
+			description: "two words (camel case)",
+			input:       "HelloWorld",
+			expected:    "hello_world",
+		},
+		{
+			description: "two words with space",
+			input:       "Hello World",
+			expected:    "hello_world",
+		},
+		{
+			description: "two words with space and underscore",
+			input:       "Hello_World",
+			expected:    "hello_world",
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.description, func(t *testing.T) {
+			actual := ToSnakeCase(tc.input)
+			if actual != tc.expected {
+				t.Errorf("expected %s, got %s", tc.expected, actual)
+			}
+		})
+	}
+}