index : iCE40/yosys	master
	[no description]

aboutsummaryrefslogtreecommitdiffstats

log msg author committer range

path: root/techlibs/intel/synth_intel.cc

	Commit message (Expand)	Author	Age	Files	Lines
*	synth_intel: Remove incomplete Arria 10 GX support.	Marcelina Kościelnicka	2020-08-21	1	-7/+3
*	intel: move Cyclone V support to intel_alm	Dan Ravensloft	2020-08-20	1	-4/+7
*	Replace opt_rmdff with opt_dff.	Marcelina Kościelnicka	2020-08-07	1	-2/+0
*	intel: Use dfflegalize.	Marcelina Kościelnicka	2020-07-13	1	-1/+5
*	Use C++11 final/override keywords.	whitequark	2020-06-18	1	-4/+4
*	Get rid of dffsr2dff.	Marcelina Kościelnicka	2020-04-15	1	-1/+0
*	Add log_experimental() and experimental() API and "yosys -x"	Claire Wolf	2020-01-27	1	-1/+1
*	Merge pull request #1604 from whitequark/unify-ram-naming	whitequark	2020-01-02	1	-5/+5
|\
| *	Harmonize BRAM/LUTRAM descriptions across all of Yosys.	whitequark	2020-01-01	1	-5/+5
* |	Update doc that "-retime" calls abc with "-dff -D 1"	Eddie Hung	2019-12-30	1	-1/+1
* |	Revert "Revert "synth_* with -retime option now calls abc with -D 1 as well""	Eddie Hung	2019-12-30	1	-1/+1
|/
*	synth_intel: a10gx -> arria10gx	Dan Ravensloft	2019-12-10	1	-3/+3
*	synth_intel: cyclone10 -> cyclone10lp	Dan Ravensloft	2019-12-10	1	-3/+3
*	Merge branch 'ZirconiumX-synth_intel_m9k'	Clifford Wolf	2019-07-25	1	-3/+9
|\
| *	intel: Map M9K BRAM only on families that have it	Dan Ravensloft	2019-07-23	1	-3/+10
* |	intel: Make -noiopads the default	Dan Ravensloft	2019-07-24	1	-8/+8
|/
*	Merge pull request #1208 from ZirconiumX/intel_cleanups	David Shah	2019-07-18	1	-29/+14
|\
| *	synth_intel: Use stringf	Dan Ravensloft	2019-07-18	1	-7/+2
| *	synth_intel: s/not family/no family/	Dan Ravensloft	2019-07-18	1	-2/+2
| *	intel_synth: Fix help message	Ben Widawsky	2019-07-18	1	-1/+1
| *	intel_synth: Small code cleanup to remove if ladder	Ben Widawsky	2019-07-18	1	-28/+10
| *	intel_synth: Make family explicit and match	Ben Widawsky	2019-07-18	1	-2/+6
| *	intel_synth: Minor code cleanups	Ben Widawsky	2019-07-18	1	-2/+6
* |	synth_intel: rename for consistency with #1184	Dan Ravensloft	2019-07-18	1	-4/+4
|/
*	synth_intel: Warn about untested Quartus backend	Dan Ravensloft	2019-07-07	1	-0/+3
*	Fix formatting for synth_intel.cc	Ben Widawsky	2019-05-09	1	-222/+211
*	Unify usage of noflatten among architectures	Miodrag Milanovic	2019-01-04	1	-2/+2
*	Consistent use of 'override' for virtual methods in derived classes.	Henner Zeller	2018-07-20	1	-6/+6
*	Add "synth_intel --noiopads"	Clifford Wolf	2018-04-30	1	-2/+11
*	Fixed broken Quartus backend on dffeas init value (Error (12170): Illegal val...	c60k28	2018-03-31	1	-4/+23
*	Add "dffinit -highlow" and fix synth_intel	Clifford Wolf	2018-01-09	1	-1/+1
*	Initial Cyclone 10 support	dh73	2017-11-08	1	-1/+5
*	Clean whitespace and permissions in techlibs/intel	Larry Doolittle	2017-10-05	1	-3/+3
*	Rename "write_verilog -nobasenradix" to "write_verilog -decimal"	Clifford Wolf	2017-10-03	1	-4/+1
*	Adding Cyclone IV (E, GX), Arria 10, Cyclone V and LPM functions (ALTPLL and ...	dh73	2017-10-01	1	-0/+241

generated by cgit v1.2.3 (git 2.25.1) at 2025-06-28 03:43:46 +0000

# Defining a Mock Class #

## Mocking a Normal Class ##

Given
```
class Foo {
  ...
  virtual ~Foo();
  virtual int GetSize() const = 0;
  virtual string Describe(const char* name) = 0;
  virtual string Describe(int type) = 0;
  virtual bool Process(Bar elem, int count) = 0;
};
```
(note that `~Foo()` **must** be virtual) we can define its mock as
```
#include "gmock/gmock.h"

class MockFoo : public Foo {
  MOCK_CONST_METHOD0(GetSize, int());
  MOCK_METHOD1(Describe, string(const char* name));
  MOCK_METHOD1(Describe, string(int type));
  MOCK_METHOD2(Process, bool(Bar elem, int count));
};
```

To create a "nice" mock object which ignores all uninteresting calls,
or a "strict" mock object, which treats them as failures:
```
NiceMock<MockFoo> nice_foo;     // The type is a subclass of MockFoo.
StrictMock<MockFoo> strict_foo; // The type is a subclass of MockFoo.
```

## Mocking a Class Template ##

To mock
```
template <typename Elem>
class StackInterface {
 public:
  ...
  virtual ~StackInterface();
  virtual int GetSize() const = 0;
  virtual void Push(const Elem& x) = 0;
};
```
(note that `~StackInterface()` **must** be virtual) just append `_T` to the `MOCK_*` macros:
```
template <typename Elem>
class MockStack : public StackInterface<Elem> {
 public:
  ...
  MOCK_CONST_METHOD0_T(GetSize, int());
  MOCK_METHOD1_T(Push, void(const Elem& x));
};
```

## Specifying Calling Conventions for Mock Functions ##

If your mock function doesn't use the default calling convention, you
can specify it by appending `_WITH_CALLTYPE` to any of the macros
described in the previous two sections and supplying the calling
convention as the first argument to the macro. For example,
```
  MOCK_METHOD_1_WITH_CALLTYPE(STDMETHODCALLTYPE, Foo, bool(int n));
  MOCK_CONST_METHOD2_WITH_CALLTYPE(STDMETHODCALLTYPE, Bar, int(double x, double y));
```
where `STDMETHODCALLTYPE` is defined by `<objbase.h>` on Windows.

# Using Mocks in Tests #

The typical flow is:
  1. Import the Google Mock names you need to use. All Google Mock names are in the `testing` namespace unless they are macros or otherwise noted.
  1. Create the mock objects.
  1. Optionally, set the default actions of the mock objects.
  1. Set your expectations on the mock objects (How will they be called? What wil they do?).
  1. Exercise code that uses the mock objects; if necessary, check the result using [Google Test](http://code.google.com/p/googletest/) assertions.
  1. When a mock objects is destructed, Google Mock automatically verifies that all expectations on it have been satisfied.

Here is an example:
```
using ::testing::Return;                            // #1

TEST(BarTest, DoesThis) {
  MockFoo foo;                                    // #2

  ON_CALL(foo, GetSize())                         // #3
      .WillByDefault(Return(1));
  // ... other default actions ...

  EXPECT_CALL(foo, Describe(5))                   // #4
      .Times(3)
      .WillRepeatedly(Return("Category 5"));
  // ... other expectations ...

  EXPECT_EQ("good", MyProductionFunction(&foo));  // #5
}                                                 // #6
```

# Setting Default Actions #

Google Mock has a **built-in default action** for any function that
returns `void`, `bool`, a numeric value, or a pointer.

To customize the default action for functions with return type `T` globally:
```
using ::testing::DefaultValue;

DefaultValue<T>::Set(value);  // Sets the default value to be returned.
// ... use the mocks ...
DefaultValue<T>::Clear();     // Resets the default value.
```

To customize the default action for a particular method, use `ON_CALL()`:
```
ON_CALL(mock_object, method(matchers))
    .With(multi_argument_matcher)  ?
    .WillByDefault(action);
```

# Setting Expectations #

`EXPECT_CALL()` sets **expectations** on a mock method (How will it be
called? What will it do?):
```
EXPECT_CALL(mock_object, method(matchers))
    .With(multi_argument_matcher)  ?
    .Times(cardinality)            ?
    .InSequence(sequences)         *
    .After(expectations)           *
    .WillOnce(action)              *
    .WillRepeatedly(action)        ?
    .RetiresOnSaturation();        ?
```

If `Times()` is omitted, the cardinality is assumed to be:

  * `Times(1)` when there is neither `WillOnce()` nor `WillRepeatedly()`;
  * `Times(n)` when there are `n WillOnce()`s but no `WillRepeatedly()`, where `n` >= 1; or
  * `Times(AtLeast(n))` when there are `n WillOnce()`s and a `WillRepeatedly()`, where `n` >= 0.

A method with no `EXPECT_CALL()` is free to be invoked _any number of times_, and the default action will be taken each time.

# Matchers #

A **matcher** matches a _single_ argument.  You can use it inside
`ON_CALL()` or `EXPECT_CALL()`, or use it to validate a value
directly:

| `EXPECT_THAT(value, matcher)` | Asserts that `value` matches `matcher`. |
|:------------------------------|:----------------------------------------|
| `ASSERT_THAT(value, matcher)` | The same as `EXPECT_THAT(value, matcher)`, except that it generates a **fatal** failure. |

Built-in matchers (where `argument` is the function argument) are
divided into several categories:

## Wildcard ##
|`_`|`argument` can be any value of the correct type.|
|:--|:-----------------------------------------------|
|`A<type>()` or `An<type>()`|`argument` can be any value of type `type`.     |

## Generic Comparison ##

|`Eq(value)` or `value`|`argument == value`|
|:---------------------|:------------------|
|`Ge(value)`           |`argument >= value`|
|`Gt(value)`           |`argument > value` |
|`Le(value)`           |`argument <= value`|
|`Lt(value)`           |`argument < value` |
|`Ne(value)`           |`argument != value`|
|`IsNull()`            |`argument` is a `NULL` pointer (raw or smart).|
|`NotNull()`           |`argument` is a non-null pointer (raw or smart).|
|`Ref(variable)`       |`argument` is a reference to `variable`.|
|`TypedEq<type>(value)`|`argument` has type `type` and is equal to `value`. You may need to use this instead of `Eq(value)` when the mock function is overloaded.|

Except `Ref()`, these matchers make a _copy_ of `value` in case it's
modified or destructed later. If the compiler complains that `value`
doesn't have a public copy constructor, try wrap it in `ByRef()`,
e.g. `Eq(ByRef(non_copyable_value))`. If you do that, make sure
`non_copyable_value` is not changed afterwards, or the meaning of your
matcher will be changed.

## Floating-Point Matchers ##

|`DoubleEq(a_double)`|`argument` is a `double` value approximately equal to `a_double`, treating two NaNs as unequal.|
|:-------------------|:----------------------------------------------------------------------------------------------|
|`FloatEq(a_float)`  |`argument` is a `float` value approximately equal to `a_float`, treating two NaNs as unequal.  |
|`NanSensitiveDoubleEq(a_double)`|`argument` is a `double` value approximately equal to `a_double`, treating two NaNs as equal.  |
|`NanSensitiveFloatEq(a_float)`|`argument` is a `float` value approximately equal to `a_float`, treating two NaNs as equal.    |