Sure! Below is a Python function to generate test cases for the "Winter Bells" problem described in the problem statement:

```python
import random

def generate_edge_list(n, m):
    edges = []
    all_possible_edges = [(i, j) for i in range(n) for j in range(i+1, n)]
    chosen_edges = random.sample(all_possible_edges, m)
    
    for (u, v) in chosen_edges:
        weight = random.randint(1, 9999)
        edges.append((u, v, weight))
    
    return edges

def tcgen():
    test_cases = []
    
    while True:
        # Randomly decide whether to end the input
        if random.random() < 0.1:
            test_cases.append((0, 0, 0, [], []))
            break
        
        n = random.randint(3, 100)
        m = random.randint(1, n*(n-1)//2)
        p = random.randint(1, n)
        
        edges = generate_edge_list(n, m)
        
        children_nodes = [random.randint(0, n-1) for _ in range(p)]
        
        test_cases.append((n, m, p, edges, children_nodes))
    
    return test_cases

# Example of generating a test case
test_cases = tcgen()
for t in test_cases:
    n, m, p, edges, children_nodes = t
    print(f"{n} {m} {p}")
    for u, v, w in edges:
        print(f"{u} {v} {w}")
    for c in children_nodes:
        print(c)
    print()
```

### Explanation:
- **Function `generate_edge_list(n, m)`**:
  - This function generates `m` unique edges for a graph with `n` nodes.
  - It creates all possible edges, then randomly selects `m` of these edges.
  - Each edge is assigned a random weight between 1 and 9999.

- **Function `tcgen()`**:
  - This function generates multiple test cases until it randomly decides to end the input with `0 0 0`.
  - For each test case:
    - It generates random values for `n` (number of nodes), `m` (number of edges), and `p` (number of children).
    - It uses `generate_edge_list` to create a list of `m` edges.
    - It generates a list of `p` random child positions (nodes).
  - It appends each test case to the `test_cases` list.
  - Finally, it returns the list of test cases.

The test case generator function `tcgen()` will produce a list of test cases, each consisting of the number of nodes `n`, the number of edges `m`, the number of children `p`, a list of `m` edges, and a list of `p` child positions. The format of each test case corresponds to the input format specified in the problem statement.