Certainly! A test case generator for the "Winter Bells" problem can be designed to produce random graphs, as well as random children positions in the graph. Here is the Python code to generate such test cases:

```python
import random

def generate_graph(n, m):
    edges = []
    possible_edges = [(i, j) for i in range(n) for j in range(i + 1, n)]
    random.shuffle(possible_edges)
    
    for _ in range(m):
        u, v = possible_edges.pop()
        weight = random.randint(1, 9999)
        edges.append((u, v, weight))
    
    return edges

def tcgen():
    test_cases = []
    while True:
        n = random.randint(3, 100)
        m = random.randint(n-1, n*(n-1)//2)
        p = random.randint(1, n)
        
        edges = generate_graph(n, m)
        children = [random.randint(0, n-1) for _ in range(p)]
        
        test_cases.append((n, m, p, edges, children))
        
        # Break condition for the loop
        if random.random() < 0.1:  # 10% chance to stop adding more test cases
            break
    
    return test_cases

def format_test_cases(test_cases):
    formatted = []
    for n, m, p, edges, children in test_cases:
        formatted.append(f"{n} {m} {p}")
        formatted.extend(f"{u} {v} {w}" for u, v, w in edges)
        formatted.extend(f"{c}" for c in children)
        formatted.append("")  # Blank line after each dataset
    
    formatted.append("0 0 0")  # Termination line
    return "\n".join(formatted)

# Generate and format the test cases
test_cases = tcgen()
formatted_test_cases = format_test_cases(test_cases)
print(formatted_test_cases)
```

### Explanation:

1. **Graph Generation (`generate_graph`)**:
   - Generates a list of possible edges for a graph with `n` nodes.
   - Randomly selects `m` edges from the list of possible edges.
   - Assigns a random weight to each selected edge.

2. **Test Case Generation (`tcgen`)**:
   - Generates multiple test cases until a random break condition is met.
   - Each test case consists of:
     - Random number of nodes (`n`), edges (`m`), and children (`p`).
     - A randomly generated graph with `n` nodes and `m` edges.
     - Randomly selected positions for `p` children.

3. **Formatting Test Cases (`format_test_cases`)**:
   - Converts the test cases into the desired string format.
   - Adds a blank line after each dataset.
   - Adds the termination line `0 0 0`.

This generator will create well-formed, random test cases to thoroughly test your solution for the "Winter Bells" problem. You can run the code to print the generated test cases.