# ChatGPT Can’t Execute the Code It Generates (Yet) To Test It, But It Can Suggest How To

Some more casual, unconsidered prompts to, and responses from, the free ChatGPT research preview, following on from here, etc., offered without comment, except to now the programming language assumption in this one-shot test…

Generate a function to calculate a factorial. Then check that the code works. If it doesnlt revise the code and display your first and second attempts explaining the differences between them.

Me to ChatGPT
`Here is a function to calculate the factorial of a given number:`
```def factorial(n):
if n == 0:
return 1
else:
return n * factorial(n-1)

```
`To check that this code works, we can call the factorial() function with a few test cases and see if the output matches what we expect. For example:`
```print(factorial(0)) # should output 1
print(factorial(1)) # should output 1
print(factorial(2)) # should output 2
print(factorial(3)) # should output 6
```
`If the code does not produce the expected output for any of these test cases, we can revise the code and try again. For example, if the code above produced an error when trying to calculate the factorial of 0, we could revise the code to explicitly handle this case, like so:`
```def factorial(n):
if n == 0:
return 1
elif n < 0:
return None # indicate that the factorial is not defined for negative numbers
else:
return n * factorial(n-1)

print(factorial(0)) # should output 1
print(factorial(1)) # should output 1
print(factorial(2)) # should output 2
print(factorial(3)) # should output 6

```
`In this revised version of the code, we added an additional `elif` clause to handle the case where `n` is negative. This clause simply returns `None` to indicate that the factorial is not defined for negative numbers.`

Is there a way of using automated test procedures to test that the factorial function works correctly?

Me to ChatGPT
```Yes, automated testing is a common and effective way to ensure that code works as expected. In the case of the `factorial()` function, we can use a unit testing framework like `unittest` to write a series of test cases that cover different input scenarios and verify that the function produces the correct output for each case.

Here is an example of how we could use `unittest` to test the `factorial()` function:```
```import unittest

class TestFactorial(unittest.TestCase):
def test_factorial_zero(self):
self.assertEqual(factorial(0), 1)

def test_factorial_one(self):
self.assertEqual(factorial(1), 1)

def test_factorial_two(self):
self.assertEqual(factorial(2), 2)

def test_factorial_three(self):
self.assertEqual(factorial(3), 6)

if __name__ == '__main__':
unittest.main()

```
```In this code, we define a test class called `TestFactorial` that contains several test methods, each of which tests a different aspect of the `factorial()` function. Each test method uses the `assertEqual()` method to compare the output of the `factorial()` function with the expected result for a given input. If the output does not match the expected result, the test will fail and the error will be reported.

To run the tests, we simply call the `unittest.main()` method at the bottom of the file. This will automatically discover and run all of the test methods in the `TestFactorial` class, and report the results. If any of the tests fail, we can then revise the `factorial()` function and re-run the tests until all of the tests pass.```

Can your factorial function cope with partial fractions?

Me to ChatGPT
```No, the `factorial()` function that I provided only works for non-negative integers. It cannot handle partial fractions, which are numbers that have a non-integer value.

In general, the factorial of a partial fraction is not well-defined, because the factorial of a number is only defined for non-negative integers. Therefore, it would not make sense to try to calculate the factorial of a partial fraction using this function.

If you need to calculate the factorial of a partial fraction, you would need to use a different method or function that is specifically designed to handle partial fractions. I am not aware of any such method or function off the top of my head, but you may be able to find one by doing some research or asking a more specialized question.```

Your function is wrong anyway. It does not work creectly.

Me to ChatGPT

At this point, ChatGPT got stuck and I did wonder if it was trying to run a code test somewhere, even though it claims not to be able to, it being just a large language model, after all… Biut then:

Reloading, I think it must have been more a load issue on the server than anything “interesting” causing the failure…

Anyway… although ChatGPT can’t execute code, and plugging it into a remote code execution service might get very epxensive for the host, I think it might be interesting if the web based chat dialogue UI could hook into in a WASM powered code execution engine. A GreaseMonkey style script (if such things still exist) to use the new flavour Thebe to run code in the browser via JupyterLite, maybe?! (Note to self: is there a JupyterLite-R kernel yet, it being a JupyteR branded project, after all?;-) And how’s WebR coming on? Have RStudio forked that, or will they run their own browser based R-WASM build to complement Shinylive (Shiny for Python applications which run completely in the browser”)?).

## Author: Tony Hirst

I'm a Senior Lecturer at The Open University, with an interest in #opendata policy and practice, as well as general web tinkering...