Creating a virtual machine (VM) runtime with an operand stack and a context stack for frames is a fairly complex task. However, I'll start with a basic example to demonstrate the core concepts by focusing on a simplified architecture. Let's build a tiny VM where bytecode instructions can push to or pop from the operand stack, and where method calls push new frames onto the context stack.

Let's start by defining the Operand Stack, Frame (with its own local variables and return address), and the basic structure of the Virtual Machine runtime.

### Step 1: Define the Operand Stack

The Operand Stack holds operands used during instruction execution.

```java
import java.util.Stack;

public class OperandStack {
    private Stack<Integer> stack;

    public OperandStack() {
        this.stack = new Stack<>();
    }

    public void push(int value) {
        stack.push(value);
    }

    public int pop() {
        return stack.pop();
    }

    public int peek() {
        return stack.peek();
    }

    public boolean isEmpty() {
        return stack.isEmpty();
    }
}
```

### Step 2: Create a Frame

A Frame contains its own operand stack and local variables, and represents a function/method call in the VM.

```java
import java.util.HashMap;
import java.util.Map;

public class Frame {
    private OperandStack operandStack;
    private Map<Integer, Integer> localVariables;
    private int returnAddress;

    public Frame(int maxLocals) {
        operandStack = new OperandStack();
        localVariables = new HashMap<>();
        for (int i = 0; i < maxLocals; i++) {
            localVariables.put(i, 0);
        }
    }

    public OperandStack getOperandStack() {
        return operandStack;
    }

    public void setLocal(int index, int value) {
        localVariables.put(index, value);
    }

    public int getLocal(int index) {
        return localVariables.get(index);
    }

    public void setReturnAddress(int returnAddress) {
        this.returnAddress = returnAddress;
    }

    public int getReturnAddress() {
        return returnAddress;
    }
}
```

### Step 3: Define the Context Stack

A Context Stack maintains the frames for currently executing methods/functions.

```java
import java.util.Stack;

public class ContextStack {
    private Stack<Frame> frameStack;

    public ContextStack() {
        this.frameStack = new Stack<>();
    }

    public void pushFrame(Frame frame) {
        frameStack.push(frame);
    }

    public Frame popFrame() {
        return frameStack.pop();
    }

    public Frame peekFrame() {
        return frameStack.peek();
    }

    public boolean isEmpty() {
        return frameStack.isEmpty();
    }
}
```

### Step 4: Implement the Virtual Machine

Now that we have the operand stack, context stack, and frame set up, let's create a basic VM that can execute some simple bytecode instructions.

```java
public class VirtualMachine {
    private ContextStack contextStack;

    public VirtualMachine() {
        contextStack = new ContextStack();
    }

    public void run(int[] bytecode) {
        int pc = 0;  // Program Counter

        while (pc < bytecode.length) {
            int instruction = bytecode[pc];
            Frame currentFrame = contextStack.peekFrame();

            switch (instruction) {
                case 0x01:  // PUSH_CONST
                    int value = bytecode[++pc];
                    currentFrame.getOperandStack().push(value);
                    break;

                case 0x02:  // ADD
                    int operand1 = currentFrame.getOperandStack().pop();
                    int operand2 = currentFrame.getOperandStack().pop();
                    currentFrame.getOperandStack().push(operand1 + operand2);
                    break;

                case 0x03:  // STORE_LOCAL
                    int index = bytecode[++pc];
                    int result = currentFrame.getOperandStack().pop();
                    currentFrame.setLocal(index, result);
                    break;

                case 0x04:  // LOAD_LOCAL
                    index = bytecode[++pc];
                    currentFrame.getOperandStack().push(currentFrame.getLocal(index));
                    break;

                case 0x05:  // CALL
                    int newPc = bytecode[++pc];
                    int maxLocals = bytecode[++pc];
                    Frame newFrame = new Frame(maxLocals);
                    newFrame.setReturnAddress(pc + 1);
                    contextStack.pushFrame(newFrame);
                    pc = newPc - 1;  // -1 because the pc will be incremented at the end of the loop
                    break;

                case 0x06:  // RETURN
                    int returnValue = currentFrame.getOperandStack().pop();
                    int returnAddress = currentFrame.getReturnAddress();
                    contextStack.popFrame();
                    contextStack.peekFrame().getOperandStack().push(returnValue);
                    pc = returnAddress - 1; // -1 because the pc will be incremented at the end of the loop
                    break;

                default:
                    throw new RuntimeException("Unknown instruction: " + instruction);
            }
            pc++;
        }
    }
}
```

### Step 5: Test the Virtual Machine

We can now create a small program that pushes constants to the stack, adds them, and stores the result in a local variable. Additionally, we'll call one function that simply returns 42.

Here's an example:

```java
public class Main {
    public static void main(String[] args) {
        VirtualMachine vm = new VirtualMachine();

        // Bytecode to execute
        int[] bytecode = new int[] {
            0x01, 10,    // PUSH_CONST 10
            0x01, 20,    // PUSH_CONST 20
            0x02,        // ADD
            0x03, 0,     // STORE_LOCAL 0 (store the result in local variable 0)
            
            0x01, 42,    // PUSH_CONST 42
            0x05, 10, 1, // CALL (pc=10), maxLocals=1
            
            0x04, 0,     // LOAD_LOCAL 0 (reload stored result)
            0x02,        // ADD (add the 42 we got in the return)
        };

        // Add a simple function that returns the value passed to it
        int[] function = new int[] {
            0x06,   // RETURN
        };

        // Load the main program
        Frame mainFrame = new Frame(2); // 2 local variables
        vm.run(bytecode);
        System.out.println("Execution Finished!");
    }
}
```

### Explanation:
1. We created an example program that pushes two values onto the operand stack, adds them, and stores the result in a local variable.
2. It then loads another value (42), calls a simple "function" that just returns that value, and finally adds 42 to the previously calculated sum.

### What you should see:
The VM would execute the bytecode, simulate method calls, manage operand and context stacks, and eventually print the final result.

### Expansion:
This is a very simplified VM runtime. A more comprehensive VM would handle more complex operations, support various data types, exception handling, garbage collection, and native method integration. Additionally, the bytecode format would generally be more sophisticated and involve various optimization and execution features.