Merge pull request #9 from JSchaenzle/feature/configure-cedux-and-add-tests

Feature/configure cedux and add tests

Author: JSchaenzle

.gitignore

@@ -1 +1,2 @@
 *.out
+build/

.ruby-version

@@ -0,0 +1 @@
+2.6.3

Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gem "ceedling"

Gemfile.lock

@@ -0,0 +1,19 @@
+GEM
+  remote: https://rubygems.org/
+  specs:
+    ceedling (0.28.3)
+      constructor (>= 1.0.4)
+      rake (>= 0.8.7)
+      thor (>= 0.14.5)
+    constructor (2.0.0)
+    rake (12.3.3)
+    thor (0.20.3)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  ceedling
+
+BUNDLED WITH
+   1.17.2

README.md

@@ -76,6 +76,40 @@ To use Cedux you'll need to copy the following files into your application.
 
 See example.c for a demonstration.
 
+### Configuration
+By default, cedux has the following maximum values set:
+- Maximum of **16** actions can be dispatched between runs of the `cedux_run_store`
+- Maximum of **32** reducers can be registered
+- Maximum of **32** subscribers can be registered
+
+However, these limitations can be altered if needed. Cedux references the following defines:
+- CEDUX_MAX_ACTIONS
+- CEDUX_MAX_REDUCERS
+- CEDUX_MAX_SUBSCRIBERS
+
+You must define these values before `#include`ing cedux.h like so:
+
+```
+#define CEDUX_MAX_ACTIONS 256      // Must be a factor of 2
+#define CEDUX_MAX_REDUCERS 128     // Must be a factor of 2
+#define CEDUX_MAX_SUBSCRIBERS 256  // Must be a factor of 2
+#include "cedux.h"
+```
+
+As noted above, the CEXUX_MAX_X values must be factors of 2 in order for the cedux internals to work correctly.
+
 ### Thread Safety
 
 For applications that require thread safety guarantees, Cedux provides the option to register platform-specific locking functions around the action queue so that multiple threads can dispatch actions at the time that Cedux is processing them.  If you don't need thread safety in your application, you can skip this step.  Use the `cedux_set_threadsafe_x` function to provide a handle to a platform-specific lock variable and wrapper functions to acquire and release the lock.  Note that the lock should be initialized before passing it to Cedux.  See `threadsafe_example.c` for an implementation using POSIX threads.
+
+
+## Testing
+This project is setup with unit testing using Ceedling (Unity and CMock)
+
+### To setup testing environment
+1. Setup rbenv. This will ensure the expected version or ruby is used.
+2. Install bundler with: `gem install bundler`
+3. Install gems with: `bundle install`
+
+### To run the tests:
+ > `bundle exec rake test:all`

Rakefile

@@ -0,0 +1,9 @@
+require "bundler"
+require "pathname"
+Bundler.setup
+
+CURRENT_DIR = Pathname.new(Dir.pwd)
+CEEDLING_PATH = Pathname.new(Gem.loaded_specs["ceedling"].gem_dir).relative_path_from(CURRENT_DIR).to_s
+
+require "ceedling"
+Ceedling.load_project

cedux.h

@@ -5,6 +5,24 @@
 #include "queue.h"
 #include "list.h"
 
+#ifndef CEDUX_MAX_REDUCERS
+// Maximum number of reducers that can be registered
+// IMPORTANT: MUST BE A FACTROR OF TWO
+#define CEDUX_MAX_REDUCERS 32
+#endif
+
+#ifndef CEDUX_MAX_SUBSCRIBERS
+// Maximum number of subscribers that can be registered
+// IMPORTANT: MUST BE A FACTROR OF TWO
+#define CEDUX_MAX_SUBSCRIBERS 32
+#endif
+
+#ifndef CEDUX_MAX_ACTIONS
+// Maximum number of actions that can be dispatched between runs of the cedux_run_store()
+// IMPORTANT: MUST BE A FACTROR OF TWO
+#define CEDUX_MAX_ACTIONS 16
+#endif
+
 #define CEDUX_DECLARE_STORE(TREE_TYPE, ACTION_TYPE, STORE_NAME)                                 \
                                                                                                 \
 struct STORE_NAME##_handle;                                                                     \
@@ -17,10 +35,10 @@ struct STORE_NAME##_subscriber_container
     void *data;                                                                                 \
     STORE_NAME##_REDUCER linked_reducer;                                                        \
 };                                                                                              \
-QUEUE_TYPE_DECLARATION(STORE_NAME##_action_queue, ACTION_TYPE, 16)                              \
+QUEUE_TYPE_DECLARATION(STORE_NAME##_action_queue, ACTION_TYPE, CEDUX_MAX_ACTIONS)               \
 QUEUE_DECLARATION(STORE_NAME##_action_queue, ACTION_TYPE)                                       \
-LIST_DECLARATION(STORE_NAME##_reducer_list, STORE_NAME##_REDUCER, 32)                           \
-LIST_DECLARATION(STORE_NAME##_subscriber_list, struct STORE_NAME##_subscriber_container, 32)    \
+LIST_DECLARATION(STORE_NAME##_reducer_list, STORE_NAME##_REDUCER, CEDUX_MAX_REDUCERS)           \
+LIST_DECLARATION(STORE_NAME##_subscriber_list, struct STORE_NAME##_subscriber_container, CEDUX_MAX_SUBSCRIBERS) \
                                                                                                 \
 void cedux_register_##STORE_NAME##_reducer(struct STORE_NAME##_handle * p_store,                \
                                            STORE_NAME##_REDUCER reducer);                       \

project.yml

@@ -0,0 +1,91 @@
+---
+
+# Notes:
+# Sample project C code is not presently written to produce a release artifact.
+# As such, release build options are disabled.
+# This sample, therefore, only demonstrates running a collection of unit tests.
+
+:project:
+  :use_exceptions: FALSE
+  :use_test_preprocessor: TRUE
+  :use_auxiliary_dependencies: TRUE
+  :build_root: build
+#  :release_build: TRUE
+  :test_file_prefix: test_
+  # :which_ceedling: vendor/ceedling
+  :default_tasks:
+    - test:all
+
+#:release_build:
+#  :output: MyApp.out
+#  :use_assembly: FALSE
+
+:environment:
+
+:extension:
+  :executable: .out
+
+:paths:
+  :test:
+    - +:test/**
+    - -:test/support
+  :source:
+    - +:./
+  :support:
+    - test/support
+
+:defines:
+  # in order to add common defines:
+  #  1) remove the trailing [] from the :common: section
+  #  2) add entries to the :common: section (e.g. :test: has TEST defined)
+  :commmon: &common_defines []
+  :test:
+    - *common_defines
+    - TEST
+  :test_preprocess:
+    - *common_defines
+    - TEST
+
+:cmock:
+  :mock_prefix: mock_
+  :when_no_prototypes: :warn
+  :enforce_strict_ordering: TRUE
+  :plugins:
+    - :ignore
+    - :callback
+  :treat_as:
+    uint8:    HEX8
+    uint16:   HEX16
+    uint32:   UINT32
+    int8:     INT8
+    bool:     UINT8
+
+:gcov:
+    :html_report_type: basic
+
+#:tools:
+# Ceedling defaults to using gcc for compiling, linking, etc.
+# As [:tools] is blank, gcc will be used (so long as it's in your system path)
+# See documentation to configure a given toolchain for use
+
+# LIBRARIES
+# These libraries are automatically injected into the build process. Those specified as
+# common will be used in all types of builds. Otherwise, libraries can be injected in just
+# tests or releases. These options are MERGED with the options in supplemental yaml files.
+:libraries:
+  :placement: :end
+  :flag: "${1}"  # or "-L ${1}" for example
+  :common: &common_libraries []
+  :test:
+    - *common_libraries
+  :release:
+    - *common_libraries
+
+:plugins:
+  :load_paths:
+    - "#{CEEDLING_PATH}/plugins"
+  :enabled:
+    - stdout_pretty_tests_report
+    - module_generator
+    - raw_output_report
+...

test/support/cedux_test_helpers.h

@@ -0,0 +1,11 @@
+#ifndef CEDUX_TEXT_HELPERS_H
+#define CEDUX_TEXT_HELPERS_H
+#include <stdbool.h>
+
+bool mockable_reducer1(int * p_state, int action);
+bool mockable_reducer2(int * p_state, int action);
+// p_store is a void pointer here because we don't have access to the correct store handle type... We'll have to use a cast in the test when registering this.
+void mockable_subscriber1(void * p_store, int const * const p_state, void * p_data);
+void mockable_subscriber2(void * p_store, int const * const p_state, void * p_data);
+
+#endif

test/test_cedux_config.c

@@ -0,0 +1,87 @@
+#include "unity.h"
+#include "mock_cedux_test_helpers.h"
+
+// Define max values _before_ including cedux. Otherwise, you need to #undef and #define the values.
+#define CEDUX_MAX_ACTIONS 256 
+#define CEDUX_MAX_REDUCERS 128 
+#define CEDUX_MAX_SUBSCRIBERS 256
+
+#include "cedux.h"
+
+CEDUX_DECLARE_STORE(int, int, int_store);
+CEDUX_DEFINE_STORE(int, int, int_store);
+
+void test_cedux_can_configure_max_actions(void) {
+
+    //  Initialize a store
+    struct int_store_handle store = cedux_init_int_store();
+    store.tree = 0;
+
+    // Setup an expectation that the reducer will be called CEDUX_MAX_ACTIONS times
+    for (int i = 0; i < CEDUX_MAX_ACTIONS; i++) {
+        mockable_reducer1_ExpectAndReturn(&store.tree, i, true);
+    }
+
+    // Register the reducer
+    cedux_register_int_store_reducer(&store, mockable_reducer1);
+
+    // Dispatch CEDUX_MAX_ACTIONS. This should result in the reducer being called that many times.
+    for (int i = 0; i < CEDUX_MAX_ACTIONS; i++) {
+        cedux_dispatch_int_store(&store, i);
+    }
+
+    // Run the store
+    cedux_run_int_store(&store);
+}
+
+void test_cedux_can_configure_max_reducers(void) {
+
+    //  Initialize a store
+    struct int_store_handle store = cedux_init_int_store();
+    store.tree = 0;
+
+    // Setup an expectation that the reducer will be called CEDUX_MAX_REDUCERS times
+    for (int i = 0; i < CEDUX_MAX_REDUCERS; i++) {
+        mockable_reducer1_ExpectAndReturn(&store.tree, 1, true);
+    }
+
+    // Register the same reducer CEDUX_MAX_REDUCERS times 
+    for (int i = 0; i < CEDUX_MAX_REDUCERS; i++) {
+        cedux_register_int_store_reducer(&store, mockable_reducer1);
+    }
+
+    // Dispatch 1 action. This should result in the reducer being called CEDUX_MAX_REDUCERS times.
+    cedux_dispatch_int_store(&store, 1);
+
+    // Run the store
+    cedux_run_int_store(&store);
+}
+
+void test_cedux_can_configure_max_subscribers(void) {
+
+    //  Initialize a store
+    struct int_store_handle store = cedux_init_int_store();
+    store.tree = 0;
+
+    // Expect one reducer to be called
+    mockable_reducer1_ExpectAndReturn(&store.tree, 1, true);
+
+    // Expect max subscrber calls
+    for (int i = 0; i < CEDUX_MAX_SUBSCRIBERS; i++) {
+        mockable_subscriber1_Expect(&store, &store.tree, &i);
+    }
+
+    // Register the reducer 
+    cedux_register_int_store_reducer(&store, mockable_reducer1);
+
+    // Register max number of subscribers
+    for (int i = 0; i < CEDUX_MAX_SUBSCRIBERS; i++) {
+        cedux_register_int_store_subscriber(&store, (void (*)(struct int_store_handle *, const int * const, void *))mockable_subscriber1, &i);
+    }
+
+    // Dispatch 1 action. This should result in the subscriber being called CEDUX_MAX_SUBSCRIBERS times.
+    cedux_dispatch_int_store(&store, 1);
+
+    // Run the store
+    cedux_run_int_store(&store);
+}