diff --git a/test/widgets/editor_code_test.dart b/test/widgets/editor_code_test.dart
new file mode 100644
index 00000000..876a65f5
--- /dev/null
+++ b/test/widgets/editor_code_test.dart
@@ -0,0 +1,341 @@
+import 'package:flutter/material.dart';
+import 'package:flutter_highlight/themes/xcode.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:flutter_code_editor/flutter_code_editor.dart';
+import 'package:flutter_highlight/themes/monokai.dart';
+import 'package:highlight/languages/javascript.dart';
+import 'package:highlight/languages/json.dart';
+import 'package:apidash_design_system/apidash_design_system.dart';
+import 'package:apidash/widgets/editor_code.dart';
+import '../test_consts.dart';
+
+void main() {
+  group('CodeEditor Widget Tests', () {
+    late CodeController testController;
+
+    setUp(() {
+      testController = CodeController(
+        text: 'print("Hello World")',
+        language: javascript,
+      );
+    });
+
+    testWidgets('renders CodeEditor with default parameters', (tester) async {
+      await tester.pumpWidget(
+        MaterialApp(
+          title: 'CodeEditor Test',
+          theme: kThemeDataLight,
+          home: Scaffold(
+            body: CodeEditor(
+              controller: testController,
+            ),
+          ),
+        ),
+      );
+
+      expect(find.byType(CodeEditor), findsOneWidget);
+      expect(find.byType(CodeField), findsOneWidget);
+      expect(find.byType(CodeTheme), findsOneWidget);
+    });
+
+    testWidgets('renders CodeEditor in read-only mode', (tester) async {
+      await tester.pumpWidget(
+        MaterialApp(
+          title: 'CodeEditor ReadOnly Test',
+          theme: kThemeDataLight,
+          home: Scaffold(
+            body: CodeEditor(
+              controller: testController,
+              readOnly: true,
+            ),
+          ),
+        ),
+      );
+
+      expect(find.byType(CodeEditor), findsOneWidget);
+
+      // Verify the CodeField is in read-only mode
+      final codeField = tester.widget<CodeField>(find.byType(CodeField));
+      expect(codeField.readOnly, isTrue);
+    });
+
+    testWidgets('renders CodeEditor in editable mode by default',
+        (tester) async {
+      await tester.pumpWidget(
+        MaterialApp(
+          title: 'CodeEditor Editable Test',
+          theme: kThemeDataLight,
+          home: Scaffold(
+            body: CodeEditor(
+              controller: testController,
+            ),
+          ),
+        ),
+      );
+
+      expect(find.byType(CodeEditor), findsOneWidget);
+
+      // Verify the CodeField is editable by default
+      final codeField = tester.widget<CodeField>(find.byType(CodeField));
+      expect(codeField.readOnly, isFalse);
+    });
+
+    testWidgets('CodeEditor has correct decoration properties', (tester) async {
+      await tester.pumpWidget(
+        MaterialApp(
+          title: 'CodeEditor Decoration Test',
+          theme: kThemeDataLight,
+          home: Scaffold(
+            body: CodeEditor(
+              controller: testController,
+            ),
+          ),
+        ),
+      );
+
+      final codeField = tester.widget<CodeField>(find.byType(CodeField));
+      final decoration = codeField.decoration as BoxDecoration;
+
+      // Check border radius
+      expect(decoration.borderRadius, equals(kBorderRadius8));
+
+      // Check that decoration has a border and color
+      expect(decoration.border, isNotNull);
+      expect(decoration.color, isNotNull);
+    });
+
+    testWidgets('CodeEditor has correct gutter style properties',
+        (tester) async {
+      await tester.pumpWidget(
+        MaterialApp(
+          title: 'CodeEditor Gutter Test',
+          theme: kThemeDataLight,
+          home: Scaffold(
+            body: CodeEditor(
+              controller: testController,
+            ),
+          ),
+        ),
+      );
+
+      final codeField = tester.widget<CodeField>(find.byType(CodeField));
+      final gutterStyle = codeField.gutterStyle;
+
+      expect(gutterStyle.width, equals(0));
+      expect(gutterStyle.margin, equals(2));
+      expect(gutterStyle.textAlign, equals(TextAlign.left));
+      expect(gutterStyle.showFoldingHandles, isFalse);
+      expect(gutterStyle.showLineNumbers, isFalse);
+    });
+
+    testWidgets('CodeEditor has correct smart typing settings', (tester) async {
+      await tester.pumpWidget(
+        MaterialApp(
+          title: 'CodeEditor Smart Typing Test',
+          theme: kThemeDataLight,
+          home: Scaffold(
+            body: CodeEditor(
+              controller: testController,
+            ),
+          ),
+        ),
+      );
+
+      final codeField = tester.widget<CodeField>(find.byType(CodeField));
+
+      expect(codeField.smartDashesType, equals(SmartDashesType.enabled));
+      expect(codeField.smartQuotesType, equals(SmartQuotesType.enabled));
+    });
+
+    testWidgets('CodeEditor expands to fill available space', (tester) async {
+      await tester.pumpWidget(
+        MaterialApp(
+          title: 'CodeEditor Expand Test',
+          theme: kThemeDataLight,
+          home: Scaffold(
+            body: CodeEditor(
+              controller: testController,
+            ),
+          ),
+        ),
+      );
+
+      final codeField = tester.widget<CodeField>(find.byType(CodeField));
+      expect(codeField.expands, isTrue);
+    });
+
+    testWidgets('CodeEditor uses correct text style with theme font size',
+        (tester) async {
+      await tester.pumpWidget(
+        MaterialApp(
+          title: 'CodeEditor Text Style Test',
+          theme: kThemeDataLight,
+          home: Scaffold(
+            body: CodeEditor(
+              controller: testController,
+            ),
+          ),
+        ),
+      );
+
+      final codeField = tester.widget<CodeField>(find.byType(CodeField));
+      final textStyle = codeField.textStyle;
+
+      // Verify that text style is based on kCodeStyle
+      expect(textStyle?.fontFamily, equals(kCodeStyle.fontFamily));
+
+      // Verify that font size is taken from theme
+      final themeContext = tester.element(find.byType(CodeEditor));
+      final expectedFontSize =
+          Theme.of(themeContext).textTheme.bodyMedium?.fontSize;
+      expect(textStyle?.fontSize, equals(expectedFontSize));
+    });
+
+    testWidgets('CodeEditor uses theme colors for background and cursor',
+        (tester) async {
+      await tester.pumpWidget(
+        MaterialApp(
+          title: 'CodeEditor Colors Test',
+          theme: kThemeDataLight,
+          home: Scaffold(
+            body: CodeEditor(
+              controller: testController,
+            ),
+          ),
+        ),
+      );
+
+      final codeField = tester.widget<CodeField>(find.byType(CodeField));
+      final themeContext = tester.element(find.byType(CodeEditor));
+      final colorScheme = Theme.of(themeContext).colorScheme;
+
+      // Verify background color
+      expect(codeField.background, equals(colorScheme.surfaceContainerLowest));
+
+      // Verify cursor color
+      expect(codeField.cursorColor, equals(colorScheme.primary));
+
+      // Verify decoration background color
+      final decoration = codeField.decoration as BoxDecoration;
+      expect(decoration.color, equals(colorScheme.surfaceContainerLowest));
+    });
+
+    testWidgets('CodeEditor with custom controller content', (tester) async {
+      final customController = CodeController(
+        text: '{\n  "key": "value",\n  "number": 42\n}',
+        language: json,
+      );
+
+      await tester.pumpWidget(
+        MaterialApp(
+          title: 'CodeEditor Custom Content Test',
+          theme: kThemeDataLight,
+          home: Scaffold(
+            body: CodeEditor(
+              controller: customController,
+            ),
+          ),
+        ),
+      );
+
+      expect(find.byType(CodeEditor), findsOneWidget);
+
+      // Verify the controller is properly set
+      final codeField = tester.widget<CodeField>(find.byType(CodeField));
+      expect(codeField.controller, equals(customController));
+      expect(codeField.controller.text, contains('"key": "value"'));
+    });
+
+    testWidgets('CodeEditor with all parameters set', (tester) async {
+      await tester.pumpWidget(
+        MaterialApp(
+          title: 'CodeEditor All Parameters Test',
+          theme: kThemeDataDark,
+          home: Scaffold(
+            body: CodeEditor(
+              controller: testController,
+              readOnly: true,
+              isDark: true,
+            ),
+          ),
+        ),
+      );
+
+      expect(find.byType(CodeEditor), findsOneWidget);
+
+      final codeField = tester.widget<CodeField>(find.byType(CodeField));
+      final codeTheme = tester.widget<CodeTheme>(find.byType(CodeTheme));
+
+      // Verify all parameters are applied
+      expect(codeField.readOnly, isTrue);
+      expect(codeTheme.data?.styles, equals(monokaiTheme));
+      expect(codeField.controller, equals(testController));
+    });
+
+    testWidgets('CodeEditor widget key is properly set', (tester) async {
+      const testKey = Key('test-code-editor');
+
+      await tester.pumpWidget(
+        MaterialApp(
+          title: 'CodeEditor Key Test',
+          theme: kThemeDataLight,
+          home: Scaffold(
+            body: CodeEditor(
+              key: testKey,
+              controller: testController,
+            ),
+          ),
+        ),
+      );
+
+      expect(find.byKey(testKey), findsOneWidget);
+      expect(find.byType(CodeEditor), findsOneWidget);
+    });
+
+    testWidgets('renders CodeEditor with light theme (isDark: false)',
+        (tester) async {
+      await tester.pumpWidget(
+        MaterialApp(
+          title: 'CodeEditor Light Theme Test',
+          theme: kThemeDataLight,
+          home: Scaffold(
+            body: CodeEditor(
+              controller: testController,
+              isDark: false,
+            ),
+          ),
+        ),
+      );
+
+      expect(find.byType(CodeEditor), findsOneWidget);
+      expect(find.byType(CodeField), findsOneWidget);
+
+      // Verify the CodeTheme is using light theme (xcode)
+      final codeTheme = tester.widget<CodeTheme>(find.byType(CodeTheme));
+      expect(codeTheme.data?.styles, equals(xcodeTheme));
+    });
+
+    testWidgets('renders CodeEditor with dark theme (isDark: true)',
+        (tester) async {
+      await tester.pumpWidget(
+        MaterialApp(
+          title: 'CodeEditor Dark Theme Test',
+          theme: kThemeDataDark,
+          home: Scaffold(
+            body: CodeEditor(
+              controller: testController,
+              isDark: true,
+            ),
+          ),
+        ),
+      );
+
+      expect(find.byType(CodeEditor), findsOneWidget);
+      expect(find.byType(CodeField), findsOneWidget);
+
+      // Verify the CodeTheme is using dark theme (monokai)
+      final codeTheme = tester.widget<CodeTheme>(find.byType(CodeTheme));
+      expect(codeTheme.data?.styles, equals(monokaiTheme));
+    });
+  });
+}